Define schema for declarative configuration of queries - mapping to entity types

[dosumis]

STATUS: DRAFT

entity_query:
[ { entity_type: ['Neuron', 'Class'], Queries: ['some_query1',...]} ,
  { entity_type: ['Synaptic_neuropil', 'Class'], Queries: [''] 
queries:
   query_name: 'some_query1'
   query_text: ''

some_query1 = query name in code.

@Robbie1977 to document complex logic currently in use to defined which queries to make available for which entity types:

Examples of NOT & OR. Can we remove the need for this with more semantic_tags/

[dosumis]

Is there some pre-existing format we can use?

If we are supporting OR and NOT - can we use a generic prefix pattern for composition with a standard set of boolean operators + negation?

[hkir-dev]

We may use a Graphql like syntax
logic operators: https://dgraph.io/docs/graphql/queries/and-or-not/
list operators (in, nin (not in)): https://www.gatsbyjs.com/docs/graphql-reference/

entity_type: { in: ['Neuron', 'Class'] }

entity_type: {
    and: [
       {in: ['Neuron', 'Class']}
       {nin: ['Anatomy']}
    ]
}

entity_type: {
    or: [
        { and: [ {in: ['Neuron', 'Class']} {nin: ['Anatomy']} ] }
        { in: ['Person'] }
    ]
}

But we will need to implement the query parsing logic by ourselves.

[Robbie1977]

If there is no off the self interpreters we could go ultra-readable by using:

term:
  tags:
    - (X AND Y) OR (A AND B AND (NOT C))

Then we can use something like:

import re

# Define a function to evaluate the logic for a given set of tags
def evaluate_tags(tags, tag_dict):
    result = []
    for tag in tags:
        if tag.startswith("(") and tag.endswith(")"):
            # Recursively evaluate nested logic within parentheses
            nested_result = evaluate_tags(re.findall(r"\b[A-Z]+\b", tag), tag_dict)
            if " OR " in tag:
                # Use any() to return True if at least one of the nested conditions is True
                result.append(any(nested_result))
            else:
                # Use all() to return True only if all of the nested conditions are True
                result.append(all(nested_result))
        else:
            # Look up the tag in the tag dictionary and return True or False based on its value
            negated = False
            if tag.startswith("NOT "):
                negated = True
                tag = tag[4:]
            value = tag_dict.get(tag, False)
            result.append(value != negated)
    if " OR " in tags:
        # Use any() to return True if at least one of the conditions is True
        return any(result)
    else:
        # Use all() to return True only if all of the conditions are True
        return all(result)

[dosumis]

QL uses prefix operators - more expressive.