snapquery 0.0.2__tar.gz → 0.0.3__tar.gz

{snapquery-0.0.2 → snapquery-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snapquery
-Version: 0.0.2
+Version: 0.0.3
 Summary: snapquery: Introduce Named Queries and Named Query Middleware to wikidata
 Project-URL: Home, https://github.com/WolfgangFahl/snapquery
 Project-URL: Documentation, https://wiki.bitplan.com/index.php/snapquery

snapquery-0.0.3/snapquery/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.3"

{snapquery-0.0.2 → snapquery-0.0.3}/snapquery/snapquery_cmd.py

@@ -42,6 +42,12 @@ class SnapQueryCmd(WebserverCmd):
             action="store_true",
             help="show the list of available endpoints",
         )
+        parser.add_argument(
+            "--limit", type=int, default=None, help="set limit parameter of query"
+        )
+        parser.add_argument(
+            "--namespace", type=str, default="wikidata-examples", help="namespace to filter queries"
+        )
         parser.add_argument("-qn", "--queryName", help="run a named query")
         parser.add_argument("-f", "--format", type=Format, choices=list(Format))
         return parser
@@ -61,14 +67,14 @@ class SnapQueryCmd(WebserverCmd):
             handled = True  # Operation handled
         elif self.args.queryName is not None:
             nqm = NamedQueryManager()
+            namespace=self.args.namespace
             name = self.args.queryName
             endpoint_name = self.args.endpointName
             r_format = self.args.format
-            sparql_query = nqm.get_sparql(name=name, endpoint_name=endpoint_name)
-            qlod = nqm.query(endpoint_name=endpoint_name, name=name)
-            query = Query(name=name, query=sparql_query, lang="sparql")
-            nqm.format_result(qlod, query, r_format, endpoint_name=endpoint_name)
-        return handled
+            limit=self.args.limit
+            formatted_result=nqm.formatted_query(name, namespace=namespace,endpoint_name=endpoint_name, r_format=r_format,limit=limit)
+            print(formatted_result)
+            return handled
 
 
 def main(argv: list = None):

{snapquery-0.0.2 → snapquery-0.0.3}/snapquery/snapquery_core.py

@@ -4,6 +4,7 @@ Created on 2024-05-03
 @author: wf
 """
 import json
+import re
 import os
 from dataclasses import field
 from pathlib import Path
@@ -14,6 +15,7 @@ from lodstorage.query import Endpoint, EndpointManager, Format, Query
 from lodstorage.sparql import SPARQL
 from lodstorage.sql import SQLDB, EntityInfo
 from lodstorage.yamlable import lod_storable
+from ngwidgets.widgets import Link
 
 
 @lod_storable
@@ -50,6 +52,37 @@ class NamedQuery:
         """
         self.query_id = f"{self.namespace}.{self.name}"
 
+    def as_link(self) -> str:
+        url = f"/query/{self.namespace}/{self.name}"
+        text = self.name
+        tooltip = "query details"
+        link = Link.create(url, text, tooltip)
+        return link
+
+    @classmethod
+    def from_record(cls, record: Dict) -> "NamedQuery":
+        """
+        Class method to instantiate NamedQuery from a dictionary record.
+        """
+        return cls(
+            namespace=record["namespace"],
+            name=record["name"],
+            title=record["title"],
+            description=record["description"],
+            sparql=record["sparql"],
+        )
+
+    def as_viewrecord(self) -> Dict:
+        """
+        Return a dictionary representing the NamedQuery with keys ordered as Name, Namespace, Title, Description.
+        """
+        return {
+            "name": self.as_link(),
+            "namespace": self.namespace,
+            "title": self.title,
+            "description": self.description,
+        }
+
 
 class NamedQueryManager:
     """
@@ -72,7 +105,7 @@ class NamedQueryManager:
         if db_path is None:
             db_path = NamedQueryManager.get_cache_path()
         self.debug = debug
-        self.sql_db = SQLDB(dbname=db_path,check_same_thread=False, debug=debug)
+        self.sql_db = SQLDB(dbname=db_path, check_same_thread=False, debug=debug)
         self.endpoints = EndpointManager.getEndpoints(lang="sparql")
 
     @classmethod
@@ -196,6 +229,7 @@ WHERE
         name: str,
         namespace: str = "wikidata-examples",
         endpoint_name: str = "wikidata",
+        limit:int=None
     ):
         """
         Execute a named SPARQL query using a specified endpoint and return the results.
@@ -204,6 +238,7 @@ WHERE
             name (str): The name of the named query to execute.
             namespace (str): The namespace of the named query, default is 'wikidata-examples'.
             endpoint_name (str): The name of the endpoint to send the SPARQL query to, default is 'wikidata'.
+            limit(int): the query limit (if any)
 
         Returns:
             Dict[str, Any]: The results of the SPARQL query in JSON format.
@@ -218,15 +253,52 @@ WHERE
             msg = f"Invalid endpoint {endpoint_name}"
             ValueError(msg)
         endpoint = self.endpoints.get(endpoint_name)
+        self.query = Query(name=name, query=sparql_query, lang="sparql",limit=limit)
+ 
         sparql = SPARQL(endpoint.endpoint)
+        if limit: 
+            # @TODO - this is to naive for cases where there are 
+            # SPARQL elements hat have a "limit" in the name e.g. "height_limit"
+            if "limit" in sparql_query or "LIMIT" in sparql_query:
+                sparql_query = re.sub(
+                    r"(limit|LIMIT)\s+(\d+)", f"LIMIT {limit}", sparql_query
+                )
+            else:
+                sparql_query += f"\nLIMIT {limit}"
         lod = sparql.queryAsListOfDicts(sparql_query)
         return lod
+    
+    def formatted_query(self,
+        name: str,
+        namespace: str = "wikidata-examples",
+        endpoint_name: str = "wikidata",
+        r_format: Format = Format.html,
+        limit:int=None)->str:
+        """
+        Execute a named SPARQL query using a specified endpoint and return the results formatted .
+
+        Args:
+            name (str): The name of the named query to execute.
+            namespace (str): The namespace of the named query, default is 'wikidata-examples'.
+            endpoint_name (str): The name of the endpoint to send the SPARQL query to, default is 'wikidata'.
+            r_format: (Format): the format to result should be returned in
+            limit(int): the query limit (if any)
+        Returns:
+            str: The results of the SPARQL query in the given format.
+
+        Raises:
+            ValueError: If no named query matches the given name and namespace.
+            Exception: If the SPARQL query execution fails or the endpoint returns an error.
+        """
+        qlod = self.query(endpoint_name=endpoint_name, name=name,namespace=namespace,limit=limit)
+        formatted_result=self.format_result(qlod=qlod, query=self.query, r_format=r_format, endpoint_name=endpoint_name)
+        return formatted_result
 
     def format_result(
         self,
         qlod: List[Dict[str, Any]],
         query: Query,
-        r_format_str: str,
+        r_format: Format,
         endpoint_name: str = "wikidata",
     ) -> Optional[str]:
         """
@@ -235,7 +307,7 @@ WHERE
         Args:
             qlod (List[Dict[str, Any]]): The list of dictionaries that represent the query results.
             query (Query): The query object which contains details like the endpoint and the database.
-            r_format_str: The format in which to print the results.
+            r_format_str(Format): The format in which to print the results.
             endpoint_name (str): The name of the endpoint to be used, defaults to "wikidata".
 
         Returns:
@@ -245,7 +317,6 @@ WHERE
         endpointConf = self.endpoints.get(endpoint_name, Endpoint.getDefault())
         query.tryItUrl = endpointConf.website
         query.database = endpointConf.database
-        r_format = Format[r_format_str] 
 
         if r_format == Format.csv:
             csv_output = CSV.toCSV(qlod)

snapquery-0.0.3/snapquery/snapquery_view.py

@@ -0,0 +1,95 @@
+"""
+Created on 2024-05-03
+
+@author: wf
+"""
+import asyncio
+from typing import List
+
+from ngwidgets.input_webserver import InputWebSolution
+from ngwidgets.lod_grid import ListOfDictsGrid
+from nicegui import ui
+
+from snapquery.snapquery_core import NamedQuery
+
+
+class NamedQuerySearch:
+    """
+    search for namedqueries
+    """
+
+    def __init__(self, solution: InputWebSolution):
+        self.solution = solution
+        self.nqm = self.solution.nqm
+        self.search_debounce_task = None
+        self.keystroke_time = 0.65  # minimum time in seconds to wait between keystrokes before starting searching
+        self.setup_ui()
+        self.namespace = "wikidata-examples"
+        self.name = ""
+
+    def setup_ui(self):
+        """
+        setup my user interface
+        """
+        with ui.row() as self.search_row:
+            self.namespace_search_input = (
+                ui.input(label="namespace", on_change=self.on_search_change)
+                .bind_value(self, "namespace")
+                .props("size=80")
+            )
+            self.name_search_input = (
+                ui.input(label="name", on_change=self.on_search_change)
+                .bind_value(self, "name")
+                .props("size=80")
+            )
+        with ui.row() as self.search_result_row:
+            self.search_result_grid = ListOfDictsGrid()
+
+    async def on_search_change(self, _args):
+        """
+        react on changes in the search input
+        """
+        # Cancel the existing search task if it's still waiting
+        if self.search_debounce_task:
+            self.search_debounce_task.cancel()
+
+        # Create a new task for the new search
+        self.search_debounce_task = asyncio.create_task(self.debounced_search())
+
+    async def debounced_search(self):
+        """
+        Waits for a period of inactivity and then performs the search.
+        """
+        try:
+            # Wait for the debounce period (keystroke_time)
+            await asyncio.sleep(self.keystroke_time)
+            sql_query = """SELECT 
+* 
+FROM NamedQuery 
+WHERE name LIKE ? and namespace LIKE? """
+            name_like = f"{self.name}%"
+            namespace_like = f"{self.namespace}%"
+            self.q_lod = self.nqm.sql_db.query(sql_query, (name_like, namespace_like))
+            self.show_lod(self.q_lod)
+
+        except asyncio.CancelledError:
+            # The search was cancelled because of new input, so just quietly exit
+            pass
+        except Exception as ex:
+            self.solution.handle_exception(ex)
+
+    def show_lod(self, q_lod: List):
+        """
+        show the given list of dicts
+        """
+        view_lod = []
+        for record in self.q_lod:
+            nq = NamedQuery.from_record(record)
+            vr = nq.as_viewrecord()
+            view_lod.append(vr)
+        if self.search_result_row:
+            with self.search_result_row:
+                ui.notify(f"found {len(q_lod)} queries")
+                self.search_result_grid.load_lod(view_lod)
+                # self.search_result_grid.set_checkbox_selection("#")
+                self.search_result_grid.update()

{snapquery-0.0.2 → snapquery-0.0.3}/snapquery/snapquery_webserver.py

@@ -2,14 +2,15 @@
 Created on 2024-05-03
 @author: wf
 """
-from fastapi import Request, Header,HTTPException
-from fastapi.responses import HTMLResponse
-from lodstorage.query import Query
+from fastapi import HTTPException
+from fastapi.responses import HTMLResponse, PlainTextResponse
+from lodstorage.query import Query, Format
 from ngwidgets.input_webserver import InputWebserver, InputWebSolution, WebserverConfig
 from nicegui import app
 from nicegui.client import Client
 
 from snapquery.snapquery_core import NamedQueryManager
+from snapquery.snapquery_view import NamedQuerySearch
 from snapquery.version import Version
 
 
@@ -39,8 +40,27 @@ class SnapQueryWebServer(InputWebserver):
         InputWebserver.__init__(self, config=SnapQueryWebServer.get_config())
         self.nqm = NamedQueryManager.from_samples()
 
-        @app.get("/query/{namespace}/{name}", response_class=HTMLResponse)
-        def query(namespace: str, name: str):
+        @app.get("/sparql/{namespace}/{name}")
+        def sparql(namespace: str, name: str) -> PlainTextResponse:
+            """
+            Gets a SPARQL query by name within a specified namespace
+
+            Args:
+                namespace (str): The namespace identifying the group or category of the query.
+                name (str): The specific name of the query to be executed.
+
+            Returns:
+                HTMLResponse: The plain text SPARQL code
+
+            Raises:
+                HTTPException: If the query cannot be found or fails to execute.
+            """
+            endpoint_name = "wikidata"
+            sparql_query = self.nqm.get_sparql(name, namespace, endpoint_name)
+            return PlainTextResponse(sparql_query)
+
+        @app.get("/query/{namespace}/{name}")
+        def query(namespace: str, name: str) -> HTMLResponse:
             """
             Executes a SPARQL query by name within a specified namespace, formats the results, and returns them as an HTML response.
 
@@ -54,22 +74,23 @@ class SnapQueryWebServer(InputWebserver):
             Raises:
                 HTTPException: If the query cannot be found or fails to execute.
             """
-            content=self.query(namespace,name)
+            content = self.query(namespace, name)
             if not content:
                 raise HTTPException(status_code=500, detail="Could not create result")
 
             # Return the content as an HTML response
             return HTMLResponse(content)
-        
-    def query(self,namespace:str,name:str):
+
+    def query(self, namespace: str, name: str):
+        """ """
         endpoint_name = "wikidata"
         # content negotiation
         # Determine response format by extension in the name or Accept header
-        if '.' in name:
-            r_format = name.split('.')[-1]
-            name = name[:name.rfind('.')]
+        if "." in name:
+            r_format_str = name.split(".")[-1]
+            name = name[: name.rfind(".")]
         else:
-            r_format = "html"
+            r_format_str = "html"
 
         # Retrieve the SPARQL query string using the namespace and name.
         try:
@@ -83,6 +104,7 @@ class SnapQueryWebServer(InputWebserver):
             raise HTTPException(status_code=404, detail=str(e))
 
         # Format the results and generate HTML content
+        r_format = Format[r_format_str]
         content = self.nqm.format_result(
             qlod, query, r_format, endpoint_name=endpoint_name
         )
@@ -104,3 +126,27 @@ class SnapQuerySolution(InputWebSolution):
             client (Client): The client instance this context is associated with.
         """
         super().__init__(webserver, client)  # Call to the superclass constructor
+        self.nqm = self.webserver.nqm
+        self.endpoint_name = "wikidata"
+
+    def configure_settings(self):
+        """
+        add additional settings
+        """
+        self.add_select("default Endpoint", list(self.nqm.endpoints.keys())).bind_value(
+            self, "endpoint_name"
+        )
+
+    def setup_ui(self):
+        """
+        setup my user interface
+        """
+        self.search = NamedQuerySearch(self)
+
+    async def home(
+        self,
+    ):
+        """Generates the home page with a selection of examples and
+        svg display
+        """
+        await self.setup_content_div(self.setup_ui)

{snapquery-0.0.2 → snapquery-0.0.3}/snapquery/version.py

@@ -17,7 +17,7 @@ class Version:
     name = "snapquery"
     version = snapquery.__version__
     date = "2024-05-03"
-    updated = "2024-05-03"
+    updated = "2024-05-04"
     description = "Introduce Named Queries and Named Query Middleware to wikidata"
 
     authors = "Wolfgang Fahl"

{snapquery-0.0.2 → snapquery-0.0.3}/tests/test_restful_api.py

@@ -3,21 +3,22 @@ Created on 2024-05-03
 
 @author: wf
 """
-from snapquery.snapquery_webserver import SnapQueryWebServer
-from snapquery.snapquery_cmd import SnapQueryCmd
 from ngwidgets.webserver_test import WebserverTest
 
+from snapquery.snapquery_cmd import SnapQueryCmd
+from snapquery.snapquery_webserver import SnapQueryWebServer
 
-class TestRestFullApi(WebserverTest):
+
+class TestRestFulApi(WebserverTest):
     """
     test endpoint handling according to https://github.com/WolfgangFahl/snapquery/issues/1
     """
+
     def setUp(self, debug=True, profile=True):
         server_class = SnapQueryWebServer
         cmd_class = SnapQueryCmd
         WebserverTest.setUp(self, server_class, cmd_class, debug=debug, profile=profile)
 
-   
     def testDemoWebserver(self):
         """
         test API docs access
@@ -25,10 +26,24 @@ class TestRestFullApi(WebserverTest):
         # self.debug=True
         html = self.getHtml("/docs")
         self.assertTrue("Swagger" in html)
-        
+
+    def testSparqlApi(self):
+        """
+        test the plaintext SPARQL API
+        """
+        for example in ["cats", "horses"]:
+            path = f"/sparql/wikidata-examples/{example}"
+            sparql_query = self.getHtml(path)
+            if self.debug:
+                print(sparql_query)
+            self.assertTrue("SELECT" in sparql_query)
+
     def testQueryApi(self):
-        for r_format in ["mediawiki","github","latex","html"]:
-            path=f"/query/wikidata-examples/cats.{r_format}"
-            html=self.getHtml(path)
+        """
+        test the RESTFul Query API
+        """
+        for r_format in ["mediawiki", "github", "latex", "html"]:
+            path = f"/query/wikidata-examples/cats.{r_format}"
+            html = self.getHtml(path)
             if self.debug:
                 print(html)

snapquery-0.0.2/snapquery/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.2"