snapquery 0.2.4__tar.gz → 0.2.5__tar.gz

{snapquery-0.2.4 → snapquery-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapquery
-Version: 0.2.4
+Version: 0.2.5
 Summary: Just Query wikidata and other SPARQL endpoints by query name - a frontend to Introduce Named Queries and Named Query Middleware to wikidata and other SPARQL endpoints 
 Project-URL: Home, https://github.com/WolfgangFahl/snapquery
 Project-URL: Documentation, https://wiki.bitplan.com/index.php/snapquery

snapquery-0.2.5/snapquery/__init__.py

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

snapquery-0.2.5/snapquery/query_parameterizer.py

@@ -0,0 +1,246 @@
+"""
+Created on 2025-12-16
+
+@author: wf
+"""
+import os
+import re
+import textwrap
+from typing import Optional, Dict, Any, List
+
+from lodstorage.params import Param
+from lodstorage.query import Query
+from snapquery.snapquery_core import NamedQuerySet, NamedQuery
+
+
+class QueryParameterizer:
+    """
+    Parameterizer for Scholia Query Sets.
+    Transforms Jinja2-based Scholia templates into standard
+    LoDStorage Parameterized Queries.
+    """
+
+    # Replacement for Scholia's label macro
+    LABEL_SERVICE = 'SERVICE wikibase:label { bd:serviceParam wikibase:language "[AUTO_LANGUAGE],en". }'
+
+    # Defaults for specific Scholia Aspects
+    # derived from the prompt list
+    ASPECT_DEFAULTS = {
+        "author": "Q80",          # Tim Berners-Lee
+        "authors": "Q80",
+        "award": "Q616568",       # Turing Award
+        "catalogue": "Q2463660",  # British Library catalogue
+        "chemical": "Q18216",     # Aspirin
+        "cito": "Q1054942",       # citation intent
+        "clinical": "Q12136",     # Common Cold (disease context)
+        "complex": "Q417724",     # Protein complex
+        "countries": "Q183",      # Germany
+        "country": "Q183",
+        "dataset": "Q1172284",    # Data set
+        "disease": "Q12136",      # Common Cold
+        "event": "Q2020153",      # WWW Conference
+        "gene": "Q7191",          # p53
+        "index": "Q1",            # Universe (generic fallback)
+        "language": "Q1860",      # English
+        "lexeme": "Q151326",      # Word
+        "license": "Q20007257",   # CC BY 4.0
+        "location": "Q64",        # Berlin
+        "ontology": "Q324254",    # Ontology
+        "organization": "Q95",    # Google
+        "organizations": "Q95",
+        "pathway": "Q26487",      # Metabolic pathway
+        "podcast": "Q24634210",   # The Ozymandias Project
+        "printer": "Q11226",      # Printer (the device/person)
+        "project": "Q5562725",    # WikiProject
+        "property": "P31",        # Instance of
+        "protein": "Q11060",      # Green fluorescent protein
+        "publisher": "Q203019",   # Elsevier
+        "retraction": "Q45263695", # Retracted paper example
+        "series": "Q245209",      # Book series
+        "software": "Q28865",     # Python
+        "sponsor": "Q95",         # Google
+        "taxon": "Q140",          # Lion
+        "topic": "Q21198",        # Computer Science
+        "topics": "Q21198",
+        "use": "Q1",
+        "uses": "Q1",
+        "venue": "Q180445",       # Nature (Journal)
+        "venues": "Q180445",
+        "wikiproject": "Q5562725",
+        "work": "Q13442814",      # Scientific Article
+        "works": "Q13442814"
+    }
+
+    def __init__(self, debug: bool = False):
+        self.debug = debug
+
+    def _infer_param_details(self, var_name: str, aspect: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Heuristics to determine type and default value based on variable name
+        and the query aspect (category).
+
+        Args:
+            var_name: The variable name found in the jinja template (e.g. 'q', 'target').
+            aspect: The scholia aspect derived from the query name (e.g. 'venue', 'author').
+        """
+        # Global Default
+        details = {"type": "string", "default": "Q80"}
+
+        # 1. Identify Type based on variable name
+        if var_name in ['q', 'target', 'item', 'person', 'work', 'venue', 'gene', 'disease']:
+            details["type"] = "WikidataItem"
+
+            # 2. Assign Default Value based on Aspect
+            if aspect and aspect in self.ASPECT_DEFAULTS:
+                details["default"] = self.ASPECT_DEFAULTS[aspect]
+
+            # 3. Fallback defaults if aspect is missing or generic
+            elif var_name == 'person':
+                details["default"] = "Q80"  # Tim Berners-Lee
+            elif var_name == 'work':
+                details["default"] = "Q13442814"
+            else:
+                details["default"] = "Q80"
+
+        elif var_name in ['p', 'property']:
+            details["type"] = "WikidataProperty"
+            details["default"] = "P31"
+        elif var_name in ['limit']:
+            details["type"] = "int"
+            details["default"] = 10
+        elif var_name in ['lang', 'language']:
+            details["type"] = "string"
+            details["default"] = "en"
+
+        return details
+
+    def get_queries_by_aspect(self,query_list:List[Query])->Dict[str,List[Query]]:
+        """
+        get queries by aspect
+        """
+        queries_by_aspect = {}
+        for query in query_list:
+            aspect=self.get_aspect(query.name)
+            if aspect in self.ASPECT_DEFAULTS:
+                if aspect not in queries_by_aspect:
+                    queries_by_aspect[aspect] = []
+                queries_by_aspect[aspect].append(query)
+        return queries_by_aspect
+
+    def store_query_list(self,query_list:List[Query],tag:str,path:str="/tmp/queries"):
+        """
+        Store query list sorted by aspect into separate YAML files.
+
+        Args:
+            query_list (List[Query]): List of Query objects with aspect metadata.
+            tag (str): Tag to include in filename.
+            path (str): Directory path where YAML files will be stored.
+        """
+        queries_by_aspect=self.get_queries_by_aspect(query_list)
+        # Create directory if it doesn't exist
+        os.makedirs(path, exist_ok=True)
+
+        # Store each aspect's queries in a separate YAML file
+        for aspect, queries in sorted(queries_by_aspect.items()):
+            filename = f"{tag}_{aspect}_queries.yaml"
+            filepath = os.path.join(path, filename)
+
+            with open(filepath, "w", encoding="utf-8") as f:
+                for query in queries:
+                    # work around https://github.com/yaml/pyyaml/issues/411
+                    if query.sparql:
+                        clean_sparql = textwrap.dedent(query.sparql).strip()
+                    yaml_str=query.to_yaml()
+                    f.write(yaml_str)
+            pass
+
+
+    def parameterize_query_set(self, query_set: NamedQuerySet) -> List[Query]:
+        """
+        Parameterize the given query set to produce a list of LoDStorage queries.
+
+        Args:
+            query_set (NamedQuerySet): The set of named queries to transform.
+
+        Returns:
+            List[Query]: A list of transformed LoDStorage Query objects.
+        """
+        query_list = []
+        for nq in query_set.queries:
+            query = self.parameterize_query(nq)
+            query_list.append(query)
+        return query_list
+
+    def get_aspect(self,name:str)->str:
+        aspect = None
+        if name:
+            # Split by hyphen first, as that is the standard separator in the example
+            parts = re.split(r'[-_]', name)
+            if parts:
+                aspect = parts[0].lower()
+        return aspect
+
+    def parameterize_query(self, nq: NamedQuery) -> Query:
+        """
+        Parameterize a single named query.
+
+        1. Identifies the "Aspect" from the query name (e.g. 'venue-...' -> 'venue').
+        2. Cleans Jinja2 specific imports.
+        3. Replaces Scholia Macros with standard SPARQL.
+        4. Detects variables and creates Param objects using aspect-specific defaults.
+
+        Args:
+            nq (NamedQuery): The named query input.
+
+        Returns:
+            Query: The transformed LoDStorage Query object.
+        """
+        # 0. Determine Aspect
+        # Naming convention: {aspect}-{subname} or {aspect}_{subname}
+        # e.g., "venue-curation_missing-author-item" -> "venue"
+        aspect=self.get_aspect(nq.name)
+
+        raw_sparql = nq.sparql
+
+        # 1. Remove Jinja imports
+        # e.g., {% import 'sparql-helpers.sparql' as sparql_helpers -%}
+        txt = re.sub(r'\{%\s*import\s*.*?%\}', '', raw_sparql, flags=re.DOTALL)
+
+        # 2. Replace Label/Description Macros
+        # Matches: {{ sparql_helpers.labels(["?mol"], languages) }}
+        txt = re.sub(
+            r"\{\{\s*sparql_helpers\.(labels|descriptions).*?\}\}",
+            self.LABEL_SERVICE,
+            txt,
+            flags=re.DOTALL
+        )
+
+        # 3. Detect Variables to build Param list
+        found_vars = set(re.findall(r"\{\{\s*([a-zA-Z0-9_]+)\s*\}\}", txt))
+        found_vars.discard('sparql_helpers')
+
+        # Create lodstorage Query object
+        clean_sparql = txt.strip()
+
+        query_obj = Query(
+            name=nq.name,
+            query=clean_sparql,
+            title=nq.title,
+            description=nq.description,
+            lang='sparql'
+        )
+
+        # 4. Attach Parameters with Aspect context
+        param_list = []
+        for var in sorted(found_vars):
+            details = self._infer_param_details(var, aspect=aspect)
+            p = Param(
+                name=var,
+                type=details["type"],
+                default_value=details["default"]
+            )
+            param_list.append(p)
+
+        query_obj.param_list = param_list
+
+        return query_obj

{snapquery-0.2.4 → snapquery-0.2.5}/snapquery/samples/endpoints.yaml

@@ -7,8 +7,8 @@ endpoints:
       Wikimedia Wikidata Query Service (legacy full).
       Stable but high-load; prefer -main/-scholarly.
     lang: sparql
-    endpoint: https://query.wikidata.org/sparql
-    website: https://query.wikidata.org
+    endpoint: https://query-legacy-full.wikidata.org/sparql
+    website: https://query-legacy-full.wikidata.org
     database: blazegraph
     method: POST
     calls_per_minute: 30
@@ -113,6 +113,23 @@ endpoints:
       - rdf
       - wikidata
 
+  wikidata-openlink:
+    description: |
+      OpenLink Wikidata Truthy instance (LOD Cloud demo).
+      Optimized for property path queries and transitive closure.
+      https://www.openlinksw.com/data/html/about-wikidata-truthy-2025-11.html
+    lang: sparql
+    endpoint: https://truthy.demo.openlinksw.com/sparql
+    website: https://truthy.demo.openlinksw.com
+    database: virtuoso
+    method: POST
+    calls_per_minute: 30
+    data_seeded: 2025-11-01
+    prefix_sets:
+      - rdf
+      - wikidata
+      - commons
+
   dblp:
     description: DBLP official (qlever - reliable).
     lang: sparql

{snapquery-0.2.4 → snapquery-0.2.5}/snapquery/version.py

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

{snapquery-0.2.4 → snapquery-0.2.5}/tests/test_cmdline.py

@@ -42,9 +42,11 @@ class TestCommandLine(Basetest):
 
         # Capture the output of running the command
         output = self.capture_stdout(run_cmd)
-        if self.debug:
+        debug=self.debug
+        #debug=True
+        if debug:
             print(output)
-        self.assertTrue("wikidata:https://query.wikidata.org" in output)
+        self.assertTrue("wikidata:https://query-legacy-full" in output)
 
     @unittest.skipIf(Basetest.inPublicCI(), "reading stdout in CI returns None")
     def test_namedquery(self):

snapquery-0.2.5/tests/test_scholia.py

@@ -0,0 +1,123 @@
+"""
+Created on 2024-05-04
+
+@author: wf
+"""
+
+import os
+from pathlib import Path
+import unittest
+from basemkit.basetest import Basetest
+from snapquery.scholia import ScholiaQueries, GitHubQueries
+from snapquery.snapquery_core import NamedQueryManager, NamedQuerySet
+from snapquery.query_parameterizer import QueryParameterizer
+
+class TestScholia(Basetest):
+    """
+    test scholia queries
+    """
+
+    def setUp(self, debug=True, profile=True):
+        Basetest.setUp(self, debug=debug, profile=profile)
+        self.samples_dir = Path(__file__).parent.parent / "snapquery" / "samples" / "query-sets" / "yaml"
+
+    def prepare_nqm(self,prefix:str):
+        self.prefix=prefix
+        db_path = f"/tmp/{self.prefix}_queries.db"
+        if os.path.exists(db_path):
+            os.remove(db_path)
+        # Adjust limit based on environment (e.g., CI)
+        if self.inPublicCI():
+            self.limit = 10
+        else:
+            self.limit = None
+            # limit=10
+        # Create a NamedQueryManager and ScholiaQueries instance
+        self.nqm = NamedQueryManager.from_samples(db_path=db_path)
+
+    def check_queries(self,queries,):
+        queries.store_queries()
+        queries.save_to_json(f"/tmp/{self.prefix}.json")
+
+        # Verify the data was stored
+        records = self.nqm.sql_db.query(
+            f"""SELECT *
+FROM NamedQuery
+WHERE namespace='{queries.named_query_set.namespace}'
+AND domain='{queries.named_query_set.domain}'
+"""
+        )
+        self.assertEqual(len(records), len(queries.named_query_set.queries))
+
+
+    @unittest.skipIf(Basetest.inPublicCI(), "avoid github rate limit")
+    def test_scholia_queries(self):
+        """
+        Test retrieving Scholia queries.
+        """
+        prefix="scholia"
+        nqm=self.prepare_nqm(prefix)
+        scholia_queries = ScholiaQueries(nqm, debug=self.debug)
+
+        # Extract, store, and save queries to JSON
+        scholia_queries.extract_queries(limit=self.limit)
+        self.check_queries(scholia_queries)
+
+    @unittest.skipIf(Basetest.inPublicCI(), "avoid github rate limit")
+    def test_scholia_qlever(self):
+        """
+        Test retrieving Scholia QLever queries from the specific branch.
+        """
+        prefix = "scholia_qlever"
+        nqm = self.prepare_nqm(prefix)
+
+        # Configure for ad-freiburg/scholia branch:qlever
+        scholia_qlever = ScholiaQueries(
+            nqm,
+            owner="ad-freiburg",
+            repo="scholia",
+            branch="qlever",
+            namespace="named_queries_qlever",
+            debug=self.debug
+        )
+
+        scholia_qlever.extract_queries(limit=self.limit)
+        self.check_queries(scholia_qlever)
+
+    def test_parameterizing_queries(self):
+        """
+        test parameterizing scholia queries
+        """
+        debug=self.debug
+        debug=True
+        iso_date = "2025-12-16"
+        parameterizer = QueryParameterizer(debug=debug)
+        for tag in ["scholia","scholia-qlever"]:
+            yaml_file=f"{tag}-{iso_date}.yaml"
+            yaml_path = self.samples_dir / yaml_file
+            query_set=NamedQuerySet.load_from_yaml_file(yaml_path) # @UndefinedVariable
+            query_count=len(query_set.queries)
+            if debug:
+                print(f"Parameterizing {query_count} {tag} queries")
+            pquery_list=parameterizer.parameterize_query_set(query_set)
+            parameterizer.store_query_list(pquery_list, tag)
+            self.assertEqual(len(pquery_list), query_count)
+            if debug:
+                for i,query in enumerate(pquery_list):
+                    print(f"{i}:{query.to_yaml()}")
+
+    @unittest.skipIf(Basetest.inPublicCI(), "avoid github rate limit")
+    def test_exploratory_querying_sessions(self):
+        owner = "hartig"
+        repo= "ExploratoryQueryingSessions"
+        path= "/sessions"
+        extension = ".rq"
+        limit = 5
+        prefix="hartig_eqs"
+        self.prepare_nqm(prefix)
+        show_progress=self.debug
+        show_progress=True
+        hartig_queries = GitHubQueries(self.nqm, owner=owner,repo=repo, path=path,extension=extension, debug=self.debug)
+        hartig_queries.extract_queries(limit=limit, show_progress=show_progress)
+        self.check_queries(hartig_queries)
+

snapquery-0.2.4/snapquery/__init__.py

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

snapquery-0.2.4/tests/test_scholia.py

@@ -1,246 +0,0 @@
-"""
-Created on 2024-05-04
-
-@author: wf
-"""
-import re
-import os
-from typing import Dict,List, Any
-from pathlib import Path
-import unittest
-from lodstorage.params import Param
-from basemkit.basetest import Basetest
-from lodstorage.query import Query
-from snapquery.scholia import ScholiaQueries, GitHubQueries
-from snapquery.snapquery_core import NamedQueryManager, NamedQuerySet, \
-    NamedQuery
-
-
-class QueryParameterizer:
-    """
-    Parameterizer for Scholia Query Sets.
-    Transforms Jinja2-based Scholia templates into standard
-    LoDStorage Parameterized Queries.
-    """
-    def __init__(self,debug:bool=False):
-        self.debug=debug
-
-    # Replacement for Scholia's label macro
-    LABEL_SERVICE = 'SERVICE wikibase:label { bd:serviceParam wikibase:language "[AUTO_LANGUAGE],en". }'
-
-    def _infer_param_details(self, var_name: str) -> Dict[str, Any]:
-        """
-        Heuristics to determine type and default value based on variable name.
-        """
-        details = {"type": "string", "default": "Q80"}
-
-        if var_name in ['q', 'target', 'item', 'person', 'work']:
-            details["type"] = "WikidataItem"
-            details["default"] = "Q80" # Tim Berners-Lee
-        elif var_name in ['p', 'property']:
-            details["type"] = "WikidataProperty"
-            details["default"] = "P31"
-        elif var_name in ['limit']:
-            details["type"] = "int"
-            details["default"] = 10
-        elif var_name in ['lang', 'language']:
-            details["type"] = "string"
-            details["default"] = "en"
-
-        return details
-
-    def parameterize_query_set(self, query_set: NamedQuerySet) -> List[Query]:
-        """
-        Parameterize the given query set to produce a list of LoDStorage queries.
-
-        Args:
-            query_set (NamedQuerySet): The set of named queries to transform.
-
-        Returns:
-            List[Query]: A list of transformed LoDStorage Query objects.
-        """
-        query_list = []
-        for nq in query_set.queries:
-            query = self.parameterize_query(nq)
-            query_list.append(query)
-        return query_list
-
-    def parameterize_query(self, nq: NamedQuery) -> Query:
-        """
-        Parameterize a single named query.
-
-        1. Cleans Jinja2 specific imports.
-        2. Replaces Scholia Macros (sparql_helpers) with standard SPARQL.
-        3. Detects variables and creates Param objects.
-
-        Args:
-            nq (NamedQuery): The named query input.
-
-        Returns:
-            Query: The transformed LoDStorage Query object.
-        """
-        raw_sparql = nq.sparql
-
-        # 1. Remove Jinja imports
-        # e.g., {% import 'sparql-helpers.sparql' as sparql_helpers -%}
-        txt = re.sub(r'\{%\s*import\s*.*?%\}', '', raw_sparql, flags=re.DOTALL)
-
-        # 2. Replace Label/Description Macros
-        # Matches: {{ sparql_helpers.labels(["?mol"], languages) }}
-        txt = re.sub(
-            r"\{\{\s*sparql_helpers\.(labels|descriptions).*?\}\}",
-            self.LABEL_SERVICE,
-            txt,
-            flags=re.DOTALL
-        )
-
-        # 3. Detect Variables to build Param list
-        # Look for {{ var }} patterns.
-        # Note: We keep the {{ }} syntax or convert to { } depending on how
-        # the storage engine handles format(), but here we focus on extraction.
-        found_vars = set(re.findall(r"\{\{\s*([a-zA-Z0-9_]+)\s*\}\}", txt))
-        found_vars.discard('sparql_helpers') # Ensure module names aren't params
-
-        # Create lodstorage Query object
-        # We strip surrounding whitespace generated by Jinja removals
-        clean_sparql = txt.strip()
-
-        query_obj = Query(
-            name=nq.name,
-            query=clean_sparql,
-            title=nq.title,
-            description=nq.description,
-            lang='sparql'
-        )
-
-        # 4. Attach Parameters
-        # Currently lodstorage Query doesn't have a direct 'params' list in __init__,
-        # usually it's handled via a dict or external management.
-        # However, we can use the `params` attribute if we wish to store metadata.
-        # We will create a list of Param objects.
-
-        param_list = []
-        for var in sorted(found_vars):
-            details = self._infer_param_details(var)
-            p = Param(
-                name=var,
-                type=details["type"],
-                default_value=details["default"]
-            )
-            param_list.append(p)
-
-        # Store params in the query object for subsequent usage/testing
-        # (This assumes the Query object is dynamic or we tack it on)
-        query_obj.param_list = param_list
-
-        return query_obj
-
-
-class TestScholia(Basetest):
-    """
-    test scholia queries
-    """
-
-    def setUp(self, debug=True, profile=True):
-        Basetest.setUp(self, debug=debug, profile=profile)
-        self.samples_dir = Path(__file__).parent.parent / "snapquery" / "samples" / "query-sets" / "yaml"
-
-    def prepare_nqm(self,prefix:str):
-        self.prefix=prefix
-        db_path = f"/tmp/{self.prefix}_queries.db"
-        if os.path.exists(db_path):
-            os.remove(db_path)
-        # Adjust limit based on environment (e.g., CI)
-        if self.inPublicCI():
-            self.limit = 10
-        else:
-            self.limit = None
-            # limit=10
-        # Create a NamedQueryManager and ScholiaQueries instance
-        self.nqm = NamedQueryManager.from_samples(db_path=db_path)
-
-    def check_queries(self,queries,):
-        queries.store_queries()
-        queries.save_to_json(f"/tmp/{self.prefix}.json")
-
-        # Verify the data was stored
-        records = self.nqm.sql_db.query(
-            f"""SELECT *
-FROM NamedQuery
-WHERE namespace='{queries.named_query_set.namespace}'
-AND domain='{queries.named_query_set.domain}'
-"""
-        )
-        self.assertEqual(len(records), len(queries.named_query_set.queries))
-
-
-    @unittest.skipIf(Basetest.inPublicCI(), "avoid github rate limit")
-    def test_scholia_queries(self):
-        """
-        Test retrieving Scholia queries.
-        """
-        prefix="scholia"
-        nqm=self.prepare_nqm(prefix)
-        scholia_queries = ScholiaQueries(nqm, debug=self.debug)
-
-        # Extract, store, and save queries to JSON
-        scholia_queries.extract_queries(limit=self.limit)
-        self.check_queries(scholia_queries)
-
-    @unittest.skipIf(Basetest.inPublicCI(), "avoid github rate limit")
-    def test_scholia_qlever(self):
-        """
-        Test retrieving Scholia QLever queries from the specific branch.
-        """
-        prefix = "scholia_qlever"
-        nqm = self.prepare_nqm(prefix)
-
-        # Configure for ad-freiburg/scholia branch:qlever
-        scholia_qlever = ScholiaQueries(
-            nqm,
-            owner="ad-freiburg",
-            repo="scholia",
-            branch="qlever",
-            namespace="named_queries_qlever",
-            debug=self.debug
-        )
-
-        scholia_qlever.extract_queries(limit=self.limit)
-        self.check_queries(scholia_qlever)
-
-    def test_parameterizing_queries(self):
-        """
-        test parameterizing scholia queries
-        """
-        debug=self.debug
-        debug=True
-        iso_date = "2025-12-16"
-        parameterizer = QueryParameterizer(debug=debug)
-        for tag in ["scholia","scholia-qlever"]:
-            yaml_file=f"{tag}-{iso_date}.yaml"
-            yaml_path = self.samples_dir / yaml_file
-            query_set=NamedQuerySet.load_from_yaml_file(yaml_path) # @UndefinedVariable
-            query_count=len(query_set.queries)
-            if debug:
-                print(f"Parameterizing {query_count} {tag} queries")
-            pquery_list=parameterizer.parameterize_query_set(query_set)
-            self.assertEqual(len(pquery_list), query_count)
-            if debug:
-                for i,query in enumerate(pquery_list):
-                    print(f"{i}:{query.to_yaml()}")
-
-    @unittest.skipIf(Basetest.inPublicCI(), "avoid github rate limit")
-    def test_exploratory_querying_sessions(self):
-        owner = "hartig"
-        repo= "ExploratoryQueryingSessions"
-        path= "/sessions"
-        extension = ".rq"
-        limit = 5
-        prefix="hartig_eqs"
-        self.prepare_nqm(prefix)
-        show_progress=self.debug
-        show_progress=True
-        hartig_queries = GitHubQueries(self.nqm, owner=owner,repo=repo, path=path,extension=extension, debug=self.debug)
-        hartig_queries.extract_queries(limit=limit, show_progress=show_progress)
-        self.check_queries(hartig_queries)
-