langchain-prolog 0.1.0__py3-none-any.whl

langchain_prolog/__init__.py

@@ -0,0 +1,59 @@
+"""
+langchain_prolog - A LangChain integration for SWI-Prolog
+
+This module provides a bridge between LangChain and SWI-Prolog, allowing seamless
+integration of Prolog's logic programming capabilities into LangChain pipelines.
+
+Key Components:
+    - PrologConfig: Configuration class for Prolog settings
+    - PrologRunnable: Main class for executing Prolog queries
+    - PrologTool: Utility class for integrating Prolog queries into LangChain tools
+    - PrologResult: Type representing possible Prolog query results
+    - PrologInput: Type representing valid input formats
+    - PrologRuntimeError: Exception class for Prolog execution errors
+
+Requirements:
+    - Python 3.9 or higher
+    - LangChain 0.3.0 or higher
+    - Pydantic 2.0 or higher
+    - SWI-Prolog must be installed and accessible in the system path
+    - On macOS, requires Homebrew installation of SWI-Prolog
+    - The janus_swipl package must be installed
+"""
+
+from pydantic import ValidationError
+
+from ._prolog_init import initialize_prolog
+from .exceptions import (
+    PrologFileNotFoundError,
+    PrologInitializationError,
+    PrologRuntimeError,
+    PrologToolException,
+    PrologValueError,
+)
+from .runnable import (
+    PrologConfig,
+    PrologInput,
+    PrologResult,
+    PrologRunnable,
+)
+from .tool import PrologTool
+from .__version__ import __version__
+
+
+__all__ = [
+    "PrologConfig",
+    "PrologInput",
+    "PrologRunnable",
+    "PrologRuntimeError",
+    "PrologFileNotFoundError",
+    "PrologInitializationError",
+    "PrologToolException",
+    "PrologValueError",
+    "PrologResult",
+    "PrologTool",
+    "ValidationError",
+]
+
+# Initialize Prolog immediately when this module is imported
+initialize_prolog()

langchain_prolog/__version__.py

@@ -0,0 +1,3 @@
+VERSION = (0, 1, 0)  # Major, Minor, Patch
+
+__version__ = ".".join(map(str, VERSION))

langchain_prolog/_prolog_init.py

@@ -0,0 +1,205 @@
+"""
+SWI-Prolog initialization script for Python.
+Set the following environment variables if using non-standard installation paths:
+
+For macOS
+export SWIPL_HOME_DIR=/path/to/swipl/lib/swipl
+export SWIPL_LIB_DIR=/path/to/swipl/lib/arm64-darwin
+export SWIPL_BASE_DIR=/path/to/swipl
+
+# For Linux
+export SWIPL_HOME_DIR=/path/to/swi-prolog
+export SWIPL_LIB_DIR=/path/to/swi-prolog/lib/x86_64-linux
+
+# For Windows (in PowerShell)
+$env:SWIPL_HOME_DIR="C:\path\to\swipl"
+$env:SWIPL_LIB_DIR="C:\path\to\swipl\bin"
+"""
+
+import ctypes
+import os
+import platform
+from pathlib import Path
+from typing import Optional
+
+from .exceptions import PrologInitializationError
+from .logger import logger
+
+
+def get_env_paths() -> tuple[Optional[Path], Optional[Path], Optional[Path]]:
+    """Get paths from environment variables."""
+    swipl_home = os.environ.get("SWIPL_HOME_DIR")
+    swipl_lib = os.environ.get("SWIPL_LIB_DIR")
+    swipl_base = os.environ.get("SWIPL_BASE_DIR")
+
+    return (
+        Path(swipl_home) if swipl_home else None,
+        Path(swipl_lib) if swipl_lib else None,
+        Path(swipl_base) if swipl_base else None,
+    )
+
+
+def initialize_macos() -> None:
+    """Initialize SWI-Prolog environment for macOS."""
+    # Try default Homebrew paths first
+    homebrew_base = Path("/opt/homebrew/Cellar/swi-prolog")
+    versions = [x for x in homebrew_base.iterdir() if x.is_dir()]
+    if versions:
+        swipl_base = max(versions)  # Latest version
+        arch = platform.machine()
+        swipl_lib = swipl_base / "lib" / "swipl" / "lib" / f"{arch}-darwin"
+        swipl_home = swipl_base / "lib" / "swipl"
+    else:
+        raise PrologInitializationError("No SWI-Prolog versions found in Homebrew")
+
+    # If default paths don't exist, try environment variables
+    if not swipl_lib.exists() or not swipl_home.exists():
+        env_home, env_lib, env_base = get_env_paths()
+        if env_lib and env_home and env_base:
+            swipl_lib = env_lib
+            swipl_home = env_home
+            swipl_base = env_base
+        else:
+            raise PrologInitializationError(
+                "SWI-Prolog libraries not found. Please set SWIPL_LIB_DIR, SWIPL_HOME_DIR and SWIPL_BASE_DIR"
+            )
+
+    # Create Frameworks directory
+    frameworks_dir = swipl_base / "lib" / "Frameworks"
+    frameworks_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create symbolic links
+    try:
+        for lib in swipl_lib.glob("libswipl*"):
+            target = frameworks_dir / lib.name
+            if not target.exists():
+                target.symlink_to(lib)
+    except Exception as e:
+        logger.warning(f"Could not create symbolic links: {e}")
+
+    # Set environment variables
+    os.environ["DYLD_LIBRARY_PATH"] = f"{swipl_lib}:{frameworks_dir}"
+    os.environ["SWIPL_HOME_DIR"] = str(swipl_home)
+
+    # Update system path
+    paths = [str(swipl_lib), str(frameworks_dir)]
+    for path in paths:
+        if path not in os.environ["PATH"]:
+            logger.info(f"Adding {path} to PATH")
+            os.environ["PATH"] = f"{path}:{os.environ['PATH']}"
+
+    # Load libraries
+    try:
+        ctypes.CDLL("/opt/homebrew/opt/zlib/lib/libz.1.dylib")
+        ctypes.CDLL(str(swipl_lib / "libswipl.dylib"), mode=ctypes.RTLD_GLOBAL)
+    except Exception as e:
+        logger.warning(f"Could not preload libraries: {e}")
+
+
+def initialize_linux() -> None:
+    """Initialize SWI-Prolog environment for Linux."""
+    # Try standard Linux paths
+    standard_paths = [
+        Path("/usr/lib/swi-prolog"),
+        Path("/usr/local/lib/swi-prolog"),
+    ]
+
+    swipl_lib = None
+    swipl_home = None
+
+    # Check standard paths
+    for path in standard_paths:
+        if path.exists():
+            swipl_home = path
+            swipl_lib = path / "lib" / (platform.machine() + "-linux")
+            if swipl_lib.exists():
+                break
+
+    # If standard paths don't work, try environment variables
+    if not swipl_lib or not swipl_home:
+        env_home, env_lib, _ = get_env_paths()
+        if env_lib and env_home:
+            swipl_lib = env_lib
+            swipl_home = env_home
+        else:
+            raise PrologInitializationError(
+                "SWI-Prolog libraries not found. Please set SWIPL_LIB_DIR and SWIPL_HOME_DIR"
+            )
+
+    # Set environment variables
+    os.environ["LD_LIBRARY_PATH"] = f"{swipl_lib}:{os.environ.get('LD_LIBRARY_PATH', '')}"
+    os.environ["SWIPL_HOME_DIR"] = str(swipl_home)
+
+    # Load library
+    try:
+        ctypes.CDLL(str(swipl_lib / "libswipl.so"), mode=ctypes.RTLD_GLOBAL)
+    except Exception as e:
+        logger.warning(f"Could not load SWI-Prolog library: {e}")
+
+
+def initialize_windows() -> None:
+    """Initialize SWI-Prolog environment for Windows."""
+    # Try standard Windows paths
+    standard_paths = [
+        Path("C:/Program Files/swipl"),
+        Path("C:/Program Files (x86)/swipl"),
+    ]
+
+    swipl_home = None
+    swipl_lib = None
+
+    # Check standard paths
+    for path in standard_paths:
+        if path.exists():
+            swipl_home = path
+            swipl_lib = path / "bin"
+            if swipl_lib.exists():
+                break
+
+    # If standard paths don't work, try environment variables
+    if not swipl_lib or not swipl_home:
+        env_home, env_lib, _ = get_env_paths()
+        if env_lib and env_home:
+            swipl_lib = env_lib
+            swipl_home = env_home
+        else:
+            raise PrologInitializationError(
+                "SWI-Prolog libraries not found. Please set SWIPL_LIB_DIR and SWIPL_HOME_DIR"
+            )
+
+    # Set environment variables
+    os.environ["PATH"] = f"{swipl_lib};{os.environ['PATH']}"
+    os.environ["SWIPL_HOME_DIR"] = str(swipl_home)
+
+    # Load library
+    try:
+        ctypes.CDLL(str(swipl_lib / "libswipl.dll"), mode=ctypes.RTLD_GLOBAL)
+    except Exception as e:
+        logger.warning(f"Could not load SWI-Prolog library: {e}")
+
+
+def initialize_prolog() -> None:
+    """Initialize SWI-Prolog environment based on operating system."""
+    system = platform.system().lower()
+
+    try:
+        if system == "darwin":
+            initialize_macos()
+        elif system == "linux":
+            initialize_linux()
+        elif system == "windows":
+            initialize_windows()
+        else:
+            raise PrologInitializationError(f"Unsupported operating system: {system}")
+
+        logger.info(f"SWI-Prolog initialized for {system}")
+        logger.info(f"SWIPL_HOME_DIR: {os.environ.get('SWIPL_HOME_DIR')}")
+        if system == "darwin":
+            logger.info(f"DYLD_LIBRARY_PATH: {os.environ.get('DYLD_LIBRARY_PATH')}")
+        elif system == "linux":
+            logger.info(f"LD_LIBRARY_PATH: {os.environ.get('LD_LIBRARY_PATH')}")
+        elif system == "windows":
+            logger.info(f"PATH: {os.environ.get('PATH')}")
+
+    except Exception as e:
+        raise PrologInitializationError(f"Error initializing SWI-Prolog: {e}")

langchain_prolog/consult_ex.pl

@@ -0,0 +1,47 @@
+% Consult a file and throw an exception if there are any errors.
+% Thanks to Jan Wielemaker for this code.
+% https://swi-prolog.discourse.group/uploads/short-url/9HaBWEyjPwod9QzimzPZ1OxzHIu.pl
+
+:- module(consult_ex,
+          [ consult_ex/1
+          ]).
+
+:- meta_predicate
+    consult_ex(:).
+
+consult_ex(M:Spec) :-
+    nb_setval(consult_errors, 0),
+    absolute_file_name(Spec, FullFile,
+		       [ file_type(prolog),
+			 access(read)
+		       ]),
+    setup_call_cleanup(
+        asserta((user:thread_message_hook(_Term,error,_Lines) :-
+                    consult_ex:track_messages(FullFile)), Ref),
+        consult(M:FullFile),
+        erase(Ref)),
+    nb_getval(consult_errors, N),
+    (   N =:= 0
+    ->  true
+    ;   unload_file(FullFile),
+        throw(error(consult_error(FullFile),_))
+    ).
+
+:- public
+    track_messages/1.
+
+track_messages(FullFile) :-
+    source_location(FullFile, _Line),
+    nb_getval(consult_errors, N0),
+    N is N0+1,
+    nb_setval(consult_errors, N),
+    fail.                               % print normally
+
+		 /*******************************
+		 *          MESSAGES		*
+		 *******************************/
+
+:- multifile prolog:error_message//1.
+
+prolog:error_message(consult_error(File)) -->
+    [ 'Could not load file ~p due to errors'-[File] ].

langchain_prolog/exceptions.py

@@ -0,0 +1,61 @@
+from typing import Any
+
+from langchain_core.tools import ToolException
+
+from .logger import logger
+
+
+class LangChainPrologException(Exception):
+    """Base exception class for langchain-prolog with automatic logging."""
+
+    def __init__(self, message: str, *args: Any, **kwargs: Any) -> None:
+        """Initialize exception and log it.
+
+        Args:
+            message (str): Error message
+            *args: Additional positional arguments for Exception
+            **kwargs: Additional keyword arguments. Special keys:
+                     - log_level: Logging level (default: error)
+                     - exc_info: Exception info to include in log
+        """
+        super().__init__(message, *args)
+
+        # Extract logging parameters
+        log_level = kwargs.pop("log_level", "error")
+        exc_info = kwargs.pop("exc_info", None)
+
+        # Log the exception
+        log_func = getattr(logger, log_level)
+        log_func(message, exc_info=exc_info)
+
+
+class PrologRuntimeError(LangChainPrologException):
+    """Raised when a Prolog execution error occurs."""
+
+    pass
+
+
+class PrologInitializationError(LangChainPrologException):
+    """Raised when Prolog initialization fails."""
+
+    pass
+
+
+class PrologValueError(LangChainPrologException):
+    """Raised when a value error occurs."""
+
+    pass
+
+
+class PrologFileNotFoundError(LangChainPrologException):
+    """Raised when a file is not found."""
+
+    pass
+
+
+class PrologToolException(LangChainPrologException):
+    """Raised when a Prolog tool execution error occurs."""
+
+    def __init__(self, message: str, *args: Any, **kwargs: Any) -> None:
+        super().__init__(message, *args, **kwargs)
+        raise ToolException(message, *args)

langchain_prolog/logger.py

@@ -0,0 +1,102 @@
+"""Logging configuration for the langchain-prolog library."""
+
+import logging
+import sys
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Union,
+)
+
+
+# Define custom log levels
+TRACE = 5
+logging.addLevelName(TRACE, "TRACE")
+
+
+class LangChainPrologLogger:
+    """Logger for the langchain-prolog package."""
+
+    def __init__(self, name: str = "langchain_prolog"):
+        """Initialize logger with default configuration.
+
+        Args:
+            name (str): Logger name, defaults to 'langchain_prolog'
+        """
+        self.logger = logging.getLogger(name)
+        self._configure_default_logger()
+
+    def _configure_default_logger(self) -> None:
+        """Configure default logging settings."""
+        if not self.logger.handlers:
+            self.logger.setLevel(logging.WARNING)
+
+            # Console handler
+            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler.setLevel(logging.WARNING)
+
+            # Format
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+            )
+            console_handler.setFormatter(formatter)
+
+            self.logger.addHandler(console_handler)
+
+    def setup_file_logging(self, log_file: Union[str, Path] = "langchain_prolog.log") -> None:
+        """Setup file logging.
+
+        Args:
+            log_file (str | Path): Path to log file. Defaults to 'langchain_prolog.log'.
+        """
+
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.INFO)
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        file_handler.setFormatter(formatter)
+        self.logger.addHandler(file_handler)
+
+    def set_level(self, level: int) -> None:
+        """Set logging level.
+
+        Args:
+            level (int): Logging level (e.g., logging.DEBUG, logging.INFO)
+        """
+        self.logger.setLevel(level)
+
+    def trace(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        """Log at TRACE level."""
+        self.logger.log(TRACE, msg, *args, **kwargs)
+
+    @property
+    def debug(self) -> Callable:
+        """Debug level logging."""
+        return self.logger.debug
+
+    @property
+    def info(self) -> Callable:
+        """Info level logging."""
+        return self.logger.info
+
+    @property
+    def warning(self) -> Callable:
+        """Warning level logging."""
+        return self.logger.warning
+
+    @property
+    def error(self) -> Callable:
+        """Error level logging."""
+        return self.logger.error
+
+    @property
+    def critical(self) -> Callable:
+        """Critical level logging."""
+        return self.logger.critical
+
+
+# Create default logger instance
+logger_setup = LangChainPrologLogger()
+logger = logger_setup.logger