web-algebra 1.0.0__py3-none-any.whl

web_algebra/__main__.py

@@ -0,0 +1,17 @@
+import logging
+from mcp.server.stdio import stdio_server
+import asyncio
+from .server import server
+
+logger = logging.getLogger(__name__)
+
+
+async def serve():
+    options = server.create_initialization_options()
+    async with stdio_server() as (read_stream, write_stream):
+        logger.info("Starting server with stdio")
+        await server.run(read_stream, write_stream, options)
+
+
+if __name__ == "__main__":
+    asyncio.run(serve())

web_algebra/client.py

@@ -0,0 +1,245 @@
+from typing import Optional
+import ssl
+import json
+import urllib.request
+from http.client import HTTPResponse
+from rdflib import Graph
+from rdflib.plugins.sparql.parser import parseQuery
+
+
+MEDIA_TYPES = {
+    "application/n-triples": "nt",
+    "text/turtle": "turtle",
+    "application/ld+json": "json-ld",
+    "application/rdf+xml": "xml",
+}
+
+
+class HTTPRedirectHandler308(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        """Handle 308 Permanent Redirect by preserving method and body"""
+        if code == 308:
+            return urllib.request.Request(
+                newurl, data=req.data, headers=req.headers, method=req.get_method()
+            )
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+class LinkedDataClient:
+    def __init__(
+        self,
+        cert_pem_path: Optional[str] = None,
+        cert_password: Optional[str] = None,
+        verify_ssl: bool = True,
+    ):
+        """
+        Initializes the LinkedDataClient with SSL configuration.
+
+        :param cert_pem_path: Path to the certificate .pem file (containing both private key and certificate).
+        :param cert_password: Password for the encrypted private key in the .pem file.
+        :param verify_ssl: Whether to verify the server's SSL certificate. Default is True.
+        """
+        # Always create SSL context
+        self.ssl_context = ssl.create_default_context()
+
+        # Load client certificate if provided
+        if cert_pem_path and cert_password:
+            self.ssl_context.load_cert_chain(
+                certfile=cert_pem_path, password=cert_password
+            )
+
+        # Configure SSL verification
+        if not verify_ssl:
+            self.ssl_context.check_hostname = False
+            self.ssl_context.verify_mode = ssl.CERT_NONE
+
+        # Create an HTTPS handler with the configured SSL context
+        self.opener = urllib.request.build_opener(
+            urllib.request.HTTPSHandler(context=self.ssl_context),
+            HTTPRedirectHandler308(),
+        )
+
+        # Add proper User-Agent header for external services like Wikidata
+        self.opener.addheaders = [
+            (
+                "User-Agent",
+                "Web-Algebra/1.0 (LinkedData Processing System; https://github.com/atomgraph/Web-Algebra)",
+            )
+        ]
+
+    def get(self, url: str) -> Graph:
+        """
+        Fetches RDF data from the given URL and returns it as an RDFLib Graph.
+
+        :param url: The URL to fetch RDF data from.
+        :return: An RDFLib Graph object containing the parsed RDF data.
+        """
+        # Set the Accept header
+        accept_header = ", ".join(MEDIA_TYPES.keys())
+        headers = {"Accept": accept_header}
+        request = urllib.request.Request(url, headers=headers)
+
+        # Perform the HTTP request
+        response = self.opener.open(request)
+
+        # Read and decode the response data
+        data = response.read().decode("utf-8")
+        content_type = response.headers.get("Content-Type").split(";")[0]
+        rdf_format = MEDIA_TYPES.get(content_type)
+        if not rdf_format:
+            raise ValueError(
+                f"Unsupported Content-Type: {content_type}. Supported types are: {', '.join(MEDIA_TYPES.keys())}"
+            )
+
+        # Parse the RDF data into an RDFLib Graph
+        g = Graph()
+        g.parse(data=data, format=rdf_format, publicID=url)
+        return g
+
+    def post(self, url: str, graph: Graph) -> HTTPResponse:
+        """
+        Sends RDF data to the given URL using HTTP POST.
+
+        :param url: The URL to send RDF data to.
+        :param data: An RDFLib Graph containing the data to send.
+        :return: The HTTPResponse object.
+        """
+        # Serialize the RDF data to N-Triples
+        data = graph.serialize(format="nt")
+        headers = {
+            "Content-Type": "application/n-triples",
+            "Accept": "application/n-triples",
+        }
+        request = urllib.request.Request(
+            url, data=data.encode("utf-8"), headers=headers, method="POST"
+        )
+
+        return self.opener.open(request)
+
+    def put(self, url: str, graph: Graph) -> HTTPResponse:
+        """
+        Sends RDF data to the given URL using HTTP PUT.
+
+        :param url: The URL to send RDF data to.
+        :param data: An RDFLib Graph containing the data to send.
+        :return: The HTTPResponse object.
+        """
+        # Serialize the RDF data to N-Triples
+        data = graph.serialize(format="nt")
+        headers = {
+            "Content-Type": "application/n-triples",
+            "Accept": "application/n-triples",
+        }
+        request = urllib.request.Request(
+            url, data=data.encode("utf-8"), headers=headers, method="PUT"
+        )
+
+        return self.opener.open(request)
+
+    def delete(self, url: str) -> HTTPResponse:
+        """
+        Sends an HTTP DELETE request to the given URL.
+
+        :param url: The URL to send the DELETE request to.
+        :return: The HTTPResponse object.
+        """
+        request = urllib.request.Request(url, method="DELETE")
+
+        return self.opener.open(request)
+
+    def patch(self, url: str, sparql_update: str) -> HTTPResponse:
+        """
+        Sends a SPARQL UPDATE query to the given URL using HTTP PATCH.
+
+        :param url: The URL to send the SPARQL UPDATE to.
+        :param sparql_update: The SPARQL UPDATE query string.
+        :return: The HTTPResponse object.
+        """
+        headers = {
+            "Content-Type": "application/sparql-update",
+            "Accept": "application/n-triples",
+        }
+        request = urllib.request.Request(
+            url, data=sparql_update.encode("utf-8"), headers=headers, method="PATCH"
+        )
+
+        return self.opener.open(request)
+
+
+class SPARQLClient:
+    def __init__(
+        self,
+        cert_pem_path: Optional[str] = None,
+        cert_password: Optional[str] = None,
+        verify_ssl: bool = True,
+    ):
+        """
+        Initializes the SPARQLClient with optional SSL certificate.
+
+        :param cert_pem_path: Path to .pem file containing cert+key
+        :param cert_password: Password for the PEM file
+        :param verify_ssl: Whether to verify server SSL certificate
+        """
+        # Always create SSL context
+        self.ssl_context = ssl.create_default_context()
+
+        # Load client certificate if provided
+        if cert_pem_path and cert_password:
+            self.ssl_context.load_cert_chain(
+                certfile=cert_pem_path, password=cert_password
+            )
+
+        # Configure SSL verification
+        if not verify_ssl:
+            self.ssl_context.check_hostname = False
+            self.ssl_context.verify_mode = ssl.CERT_NONE
+
+        self.opener = urllib.request.build_opener(
+            urllib.request.HTTPSHandler(context=self.ssl_context)
+        )
+
+        # Add proper User-Agent header for external services like Wikidata
+        self.opener.addheaders = [
+            (
+                "User-Agent",
+                "Web-Algebra/1.0 (LinkedData Processing System; https://github.com/atomgraph/Web-Algebra)",
+            )
+        ]
+
+    def query(self, endpoint_url: str, query_string: str) -> dict:
+        """
+        Executes a SPARQL query. Returns Graph for CONSTRUCT/DESCRIBE, Result for SELECT/ASK.
+
+        :param endpoint_url: The SPARQL endpoint URL
+        :param query_string: SPARQL query string
+        :return: rdflib.Graph or rdflib.query.Result
+        """
+        parsed = parseQuery(query_string)
+        query_type = parsed[1].name  # e.g., 'SelectQuery', 'ConstructQuery'
+
+        if query_type in {"SelectQuery", "AskQuery"}:
+            accept = "application/sparql-results+json"
+        elif query_type in {"ConstructQuery", "DescribeQuery"}:
+            accept = "application/n-triples"
+        else:
+            raise ValueError(f"Unsupported query type: {query_type}")
+
+        # Encode URL parameters
+        params = urllib.parse.urlencode({"query": query_string})
+        url = f"{endpoint_url}?{params}"
+        headers = {"Accept": accept}
+
+        request = urllib.request.Request(url, headers=headers)
+        response = self.opener.open(request)
+        data = response.read()
+
+        if accept == "application/n-triples":
+            g = Graph()
+            # convert N-Triples to JSON-LD
+            g.parse(data=data.decode("utf-8"), format="nt")
+            jsonld_str = g.serialize(format="json-ld")
+            jsonld_data = json.loads(jsonld_str)
+            return jsonld_data
+        else:
+            # return SPARQL JSON results as a dict
+            return json.loads(data.decode("utf-8"))

web_algebra/json_result.py

@@ -0,0 +1,168 @@
+from typing import List, Dict, Iterator
+from rdflib.term import Node
+from rdflib import URIRef, Literal, BNode
+from rdflib.query import Result, ResultRow
+
+
+class JSONResult(Result):
+    """
+    A SPARQL Results container that subclasses rdflib.query.Result,
+    can be constructed from SPARQL JSON format and works with RDFLib objects internally.
+    """
+
+    def __init__(self, vars: List[str], bindings: List[Dict[str, Node]]):
+        super().__init__("SELECT")  # Always SELECT type for our use case
+        self.head = {"vars": vars}
+        self.bindings = bindings
+        # Set the parent class vars attribute
+        self.vars = vars
+
+    @classmethod
+    def from_json(cls, json_dict: dict) -> "JSONResult":
+        """Construct from SPARQL JSON format"""
+        vars = json_dict["head"]["vars"]
+        bindings = []
+
+        for json_binding in json_dict["results"]["bindings"]:
+            rdf_binding = {}
+            for var, binding_dict in json_binding.items():
+                rdf_binding[var] = cls._parse_binding(binding_dict)
+            bindings.append(rdf_binding)
+
+        return cls(vars, bindings)
+
+    @staticmethod
+    def _parse_binding(binding_dict: dict) -> Node:
+        """Convert SPARQL JSON binding to RDFLib object"""
+        if binding_dict["type"] == "uri":
+            return URIRef(binding_dict["value"])
+        elif binding_dict["type"] == "literal":
+            value = binding_dict["value"]
+            datatype = binding_dict.get("datatype")
+            lang = binding_dict.get("xml:lang")
+
+            if datatype:
+                datatype = URIRef(datatype)
+
+            return Literal(value, datatype=datatype, lang=lang)
+        elif binding_dict["type"] == "bnode":
+            return BNode(binding_dict["value"])
+        else:
+            raise ValueError(f"Unknown binding type: {binding_dict['type']}")
+
+    @staticmethod
+    def _serialize_binding(term: Node) -> dict:
+        """Convert RDFLib object to SPARQL JSON binding"""
+        if isinstance(term, URIRef):
+            return {"type": "uri", "value": str(term)}
+        elif isinstance(term, Literal):
+            result = {"type": "literal", "value": str(term)}
+            if term.datatype:
+                result["datatype"] = str(term.datatype)
+            if term.language:
+                result["xml:lang"] = term.language
+            return result
+        elif isinstance(term, BNode):
+            return {"type": "bnode", "value": str(term)}
+        else:
+            raise ValueError(f"Unknown RDFLib term type: {type(term)}")
+
+    def to_json(self) -> dict:
+        """Convert back to SPARQL JSON format"""
+        json_bindings = []
+
+        for binding in self.bindings:
+            json_binding = {}
+            for var, term in binding.items():
+                json_binding[var] = self._serialize_binding(term)
+            json_bindings.append(json_binding)
+
+        return {"head": {"vars": self.vars}, "results": {"bindings": json_bindings}}
+
+    def __iter__(self) -> Iterator[ResultRow]:
+        """Allow iteration over bindings as ResultRow objects"""
+        for binding in self.bindings:
+            yield ResultRow(binding, self.vars)
+
+    def __len__(self) -> int:
+        """Number of bindings"""
+        return len(self.bindings)
+
+    def __getitem__(self, index: int) -> Dict[str, Node]:
+        """Access binding by index"""
+        return self.bindings[index]
+
+    def filter_by_position(self, position: int) -> "JSONResult":
+        """Filter to a single binding by 1-based position (XSLT-style)"""
+        if position < 1:
+            raise ValueError("Position must be >= 1 (XSLT-style 1-based indexing)")
+
+        if position > len(self.bindings):
+            raise ValueError(
+                f"Position {position} exceeds number of bindings ({len(self.bindings)})"
+            )
+
+        # Convert to 0-based index and create new result with single binding
+        filtered_binding = self.bindings[position - 1]
+        return JSONResult(self.head["vars"], [filtered_binding])
+
+    # Additional Result interface methods
+
+    def __bool__(self) -> bool:
+        """Return True if there are any bindings"""
+        return len(self.bindings) > 0
+
+    def __eq__(self, other) -> bool:
+        """Equality comparison"""
+        if not isinstance(other, JSONResult):
+            return False
+        return self.head == other.head and self.bindings == other.bindings
+
+    def __repr__(self) -> str:
+        """Developer-friendly representation"""
+        return f"JSONResult(vars={self.vars}, bindings={len(self.bindings)} rows)"
+
+    def __str__(self) -> str:
+        """Pretty table representation"""
+        if not self.bindings:
+            return f"JSONResult: {self.vars} (0 rows)\n(empty)"
+
+        # Calculate column widths
+        col_widths = {}
+        for var in self.vars:
+            col_widths[var] = max(
+                len(var),
+                max(len(str(binding.get(var, "NULL"))) for binding in self.bindings),
+            )
+
+        # Build table
+        lines = []
+
+        # Header
+        header = (
+            "| " + " | ".join(var.ljust(col_widths[var]) for var in self.vars) + " |"
+        )
+        separator = (
+            "+" + "+".join("-" * (col_widths[var] + 2) for var in self.vars) + "+"
+        )
+
+        lines.append(f"JSONResult: {self.vars} ({len(self.bindings)} rows)")
+        lines.append(separator)
+        lines.append(header)
+        lines.append(separator)
+
+        # Rows
+        for binding in self.bindings:
+            row = (
+                "| "
+                + " | ".join(
+                    str(binding.get(var, "NULL")).ljust(col_widths[var])
+                    for var in self.vars
+                )
+                + " |"
+            )
+            lines.append(row)
+
+        lines.append(separator)
+
+        return "\n".join(lines)

web_algebra/main.py

@@ -0,0 +1,149 @@
+import argparse
+import logging
+import os
+import sys
+import json
+from types import ModuleType
+from typing import List, Type, Optional
+import pkgutil
+import importlib
+import inspect
+import rdflib
+from openai import OpenAI
+from pydantic_settings import BaseSettings
+import web_algebra.operations
+from web_algebra.operation import Operation
+
+# Configure logging to show INFO level and above
+logging.basicConfig(
+    level=logging.INFO,  # ✅ Show INFO, WARNING, ERROR, and CRITICAL messages
+    format="%(asctime)s - %(levelname)s - %(message)s",  # ✅ Add timestamps for clarity
+    handlers=[logging.StreamHandler()],  # ✅ Ensure output goes to console
+)
+
+
+class LinkedDataHubSettings(BaseSettings):
+    cert_pem_path: Optional[str] = None
+    cert_password: Optional[str] = None
+    openai_client: Optional[OpenAI] = None
+    openai_model: str = "gpt-4o-mini"
+
+
+def list_operation_subclasses(
+    pkg: ModuleType, base_class: Type[Operation]
+) -> List[Type[Operation]]:
+    subclasses = []
+
+    for loader, module_name, is_pkg in pkgutil.walk_packages(
+        pkg.__path__, pkg.__name__ + "."
+    ):
+        module = importlib.import_module(module_name)
+
+        for name, obj in inspect.getmembers(module, inspect.isclass):
+            # Filter: class defined in the module AND is a subclass of Operation (but not Operation itself)
+            if (
+                obj.__module__ == module.__name__
+                and issubclass(obj, base_class)
+                and obj is not base_class
+            ):
+                subclasses.append(obj)
+
+    return subclasses
+
+
+def register(classes: List[Type[Operation]]):
+    for cls in classes:
+        Operation.register(cls)
+
+
+def main(settings: BaseSettings, json_data: Optional[str]):
+    register(list_operation_subclasses(web_algebra.operations, Operation))
+
+    if json_data:
+        logging.info("Executing from JSON input %s", json_data)
+        # Load JSON input from file
+        with open(json_data) as json_file:
+            json_input = json.load(json_file)
+
+        # Execute the JSON input
+        result = Operation.process_json(settings, json_input)
+
+        # Serialize final result for output
+        if isinstance(result, rdflib.Graph):
+            # Serialize Graph to JSON-LD for final output
+            jsonld_str = result.serialize(format="json-ld")
+            print(jsonld_str)
+        else:
+            print(result)
+    else:
+        # Load API key
+        api_key = os.getenv("OPENAI_API_KEY")
+        if api_key is None:
+            sys.exit("Error: Environment variable OPENAI_API_KEY is not set.")
+
+        client = OpenAI(api_key=api_key)
+        model = "gpt-4o-mini"
+
+        # Load prompts
+        with (
+            open("prompts/system.md") as system_prompt_file,
+            open("prompts/user.template.txt") as user_prompt_template_file,
+        ):
+            system_prompt = system_prompt_file.read()
+            messages = [{"role": "system", "content": system_prompt}]
+
+            user_prompt_template = user_prompt_template_file.read()
+
+            while True:
+                instruction = input("Instruction: ")
+
+                user_prompt = user_prompt_template.format(instruction=instruction)
+                messages.append(
+                    {"role": "user", "content": user_prompt},
+                )
+
+                chat_completion = client.chat.completions.create(
+                    model=model,
+                    messages=messages,
+                    response_format={"type": "json_object"},
+                )
+
+                reply_json = json.loads(chat_completion.choices[0].message.content)
+                assert isinstance(reply_json, dict)
+                logging.info("Generated response: %s", reply_json)
+
+                # Execute the generated operation
+                print(Operation.process_json(settings, reply_json))
+
+
+def cli() -> None:
+    parser = argparse.ArgumentParser(description="Run the AI-powered DSL interpreter.")
+    parser.add_argument(
+        "--from-json",
+        type=str,
+        help="JSON input file to execute",
+    )
+    parser.add_argument(
+        "--cert_pem_path",
+        type=str,
+        help="Path to the client certificate PEM file",
+    )
+    parser.add_argument(
+        "--cert_password",
+        type=str,
+        help="Password for the client certificate",
+    )
+    args = parser.parse_args()
+
+    if args.cert_pem_path and args.cert_password:
+        settings = LinkedDataHubSettings(
+            cert_pem_path=args.cert_pem_path, cert_password=args.cert_password
+        )
+    else:
+        settings = BaseSettings()
+
+    main(settings, args.from_json)
+
+
+if __name__ == "__main__":
+    cli()

web_algebra/mcp_tool.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class MCPTool(ABC):
+    """
+    Interface for operations that can be exposed as MCP (Model Context Protocol) tools.
+
+    Operations implementing this interface can be called directly from MCP clients
+    like Claude Desktop, providing standalone utility functionality.
+    """
+
+    @abstractmethod
+    def mcp_run(self, arguments: dict, context: Any = None) -> Any:
+        """
+        Execute the operation as an MCP tool with plain arguments.
+
+        Args:
+            arguments: Plain dictionary arguments from MCP client
+            context: Optional context (usually None for MCP calls)
+
+        Returns:
+            List of MCP content objects (TextContent, ImageContent, etc.)
+        """
+        pass