The queries package is designed for loading and executing queries against\ndatabases. It provides functionality to load queries from files or strings and\nexecute them asynchronously or synchronously. Additionally, it includes\nutilities for comparing dataframes.

\n\n

queries.query.Query

\n\n

This module is responsible for:

\n\n

Loading queries from files, directories or strings.
Executing queries against databases.
Handling both synchronous and asynchronous query execution.

\n\n

\n
We recommend using the Queries class instead of the Query class, as it\n provides additional functionality for managing multiple queries.
\n

\n\n

queries.query.Queries

\n\n

This module is responsible for:

\n\n

Managing multiple queries.
Executing multiple queries asynchronously or synchronously.
Reordering queries based on a provided list of query names.
Indexing and slicing queries.
Loading queries from files or strings.
loading queries from directories.
Executing queries against databases.
Handling both synchronous and asynchronous query execution.
Loading multiple environments and executing them against databases.

\n\n

\n
To load queries from a file or from a string you need to follow the\n specific structure defined in queries.query.get_format
\n

\n\n

queries.compare.get_differences

\n\n

This method is responsible for:

\n\n

Comparing two dataframes to identify differences.

\n\n

Installation

\n\n

To install the queries package, add the following line to your\npyproject.toml file (edit paths as needed):

\n\n

[tool.poetry.dependencies]\npython = "^3.12"\nqueries = {path = "<path to the queries package>", develop = true}\n

\n\n

After you specify the package in your pyproject.toml file, you can install it\nby running:

\n\n

poetry install\n

\n\n

Clickhouse and Postgres connections need environment variables to be set.

\n\n

Setting the environment variables can be done:

\n\n

implicitly by loading environment variables into the shell or
explicitly by setting them in the code using the configuration file.

\n\n

implicitly

\n\n

The package expects the following environment variables:

\n\n

for clickhouse connection clickhouse:\n
- CLICKHOUSE_HOST
- CLICKHOUSE_PORT
- CLICKHOUSE_USER
- CLICKHOUSE_PASSWORD
- CLICKHOUSE_DATABASE
for postgres connection postgres:\n
- POSTGRES_HOST
- POSTGRES_PORT
- POSTGRES_USER
- POSTGRES_PASSWORD
- POSTGRES_DATABASE

\n\n

explicitly

\n\n

You just need to follow the following structure\n<path_to_environments_file.json>:

\n\n

{\n    "<environment_name_for_clickhouse>": {\n        "CLICKHOUSE_HOST": "<host>",\n        "CLICKHOUSE_PORT": "<port>",\n        "CLICKHOUSE_USER": "<username>",\n        "CLICKHOUSE_PASSWORD": "<password>",\n        "CLICKHOUSE_DATABASE": "<database>",\n    },\n    "<environment_name_for_postgres>": {\n        "POSTGRES_HOST": "<host url>",\n        "POSTGRES_PORT": "<port>",\n        "POSTGRES_USER": "<username>",\n        "POSTGRES_PASSWORD": "<password>",\n        "POSTGRES_DATABASE": "<database>"\n    }\n}\n

\n\n

After you save the file, you can load the environments using the Queries object:

\n\n

from queries.query import Queries\n\nqueries = Queries(\n    source='<path_to_the_sql_file>',\n    env_config_file='<path_to_environments_file.json>'\n)\n\n# run on specific environment for example\nqueries.run_queries(env_name='<environment_name>')\n

\n\n

Variables in the configuration files have higher priority than environment\nvariables. If you set the same variable in both the configuration file and the\nenvironment, the configuration file will be used.

\n\n

\n
Don't forget that when calling a query, you need to specify the environment\n name if you have multiple environments loaded (if not set, environment\n variables will be used).
\n

\n\n

Comparing Dataframes

\n\n

If you want to use methods for comparing dataframes, you can use the compare\nmodule. It provides a method for comparing two dataframes and identifying\ndifferences between them.

\n\n

import pandas as pd\nfrom queries.compare import get_differences\n\na = pd.DataFrame({'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8]})\nb = pd.DataFrame({'a': [1, 2, 3, 5], 'b': [5, 6, 7, 8]})\n\nprint(get_differences(a, b))\n

\n"}, {"fullname": "queries.compare", "modulename": "queries.compare", "kind": "module", "doc": "

\n"}, {"fullname": "queries.compare.get_differences", "modulename": "queries.compare", "qualname": "get_differences", "kind": "function", "doc": "

Compare two dataframes.\nThis method returns rows that are different between two dataframes,\nand also it returns rows that are in one dataframe but not in the\nother.\nTo distinguish between dataframes, use left_source and right_source\narguments, which will be added to the resulting dataframe as a new column\n'source'.

\n\n

\n
It is recommended to standardize input data, meaning to round floats,\n convert all columns to the same data type (be careful with datetime).\n This method will to some degree ignore data type differences, but it is\n recommended to standardize data before comparison.
\n

\n\n

Example 1:

\n\n

import pandas as pd\nfrom queries.compare import get_differences\n\na = pd.DataFrame({'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8]})\nb = pd.DataFrame({'a': [1, 2, 3, 5], 'b': [5, 6, 7, 8]})\n\nprint(get_differences(a, b))\n

\n\n

Results:

\n\n

   a  b source\n0  4  8   left\n1  5  8  right\n

\n\n

Example 2:

\n\n

import pandas as pd\nfrom queries.compare import get_differences\n\na = pd.DataFrame({'a': [1, 2, 3, 4, 5], 'b': [5, 6, 7, 8, 9]})\nb = pd.DataFrame({'a': [1, 2, 3, 5, 6], 'b': [5, 6, 7, 8, 1]})\n\nprint(get_differences(a, b))\n

\n\n

Results:

\n\n

   a  b source\n0  5  9   left\n1  4  8   left\n2  5  8  right\n3  6  1  right\n

\n\n

The number and naming of columns depends on the input dataframes.\nThe resulting dataframe will have all columns from input dataframes (\nunion of them) and additional column 'source'.

\n\n

If there is no difference between two dataframes an empty DataFrame will be\nreturned (containing union of columns from original dataframes and\n'source' column).

\n\n

This method raises UserWarning if two dataframes don't have same column\nnames!

\n\n

Arguments:

\n\n

left (pd.DataFrame): Left dataframe.
right (pd.DataFrame): Right dataframe.
left_source (str): Source name for left dataframe.
right_source (str): Source name for right dataframe.

\n\n

Returns:

\n\n

\n
pd.DataFrame: Dataframe with differences.
\n

\n", "signature": "(\tleft: pandas.core.frame.DataFrame,\tright: pandas.core.frame.DataFrame,\tleft_source: str = 'left',\tright_source: str = 'right') -> pandas.core.frame.DataFrame:", "funcdef": "def"}, {"fullname": "queries.query", "modulename": "queries.query", "kind": "module", "doc": "

\n"}, {"fullname": "queries.query.information_to_gather", "modulename": "queries.query", "qualname": "information_to_gather", "kind": "variable", "doc": "

This dictionary contains information about the query that can be\nextracted from the query itself.\nThe dictionary contains the following\nkeys:

\n\n

name: name of the query
author: author of the query
date: date when the query was created
input_parameters: input parameters of the query
database: database on which the query is run
output: output of the query
depends: dependencies of the query
other: other information about the query

\n\n

Each key contains a dictionary with the following keys (not all keys are\npresent in all dictionaries):

\n\n

regex: dictionary with the following\nkeys:\n
- regex: regular expression to extract the information
- group_index: index of the group in the regular expression
required: boolean value if the parameter is required
format: format of the parameter
possible_values: list of possible values for the parameter
documentation_name: name of the parameter in the documentation

\n", "default_value": "{'name': {'regex': {'regex': '\\\\*\\\\s=+\\\\n\\\\s\\\\*\\\\sSQL\\\\sQuery:\\\\s*(.*)\\\\n\\\\s\\\\*\\\\s=+', 'group_index': 0}, 'required': True, 'format': ' * ============\\n * SQL Query: <name>\\n * ============', 'documentation_name': 'SQL Query'}, 'author': {'regex': {'regex': '\\\\s\\\\*\\\\sAuthor:(.*)', 'group_index': 0}, 'required': True, 'format': ' * Author: <author>', 'documentation_name': 'Author'}, 'date': {'regex': {'regex': '\\\\s\\\\*\\\\sDate:(.*)', 'group_index': 0}, 'required': True, 'format': ' * Date: <date>', 'documentation_name': 'Date'}, 'input_parameters': {'regex': {'regex': '(\\\\s\\\\*\\\\sInput\\\\sParameters:\\\\n\\\\s\\\\*\\\\s-+\\\\n((\\\\s\\\\*\\\\s-\\\\s:\\\\w+:\\\\s.*\\\\n?)+))', 'group_index': 1}, 'required': False, 'format': ' * Input parameters: <parameters>', 'documentation_name': 'Input Parameters'}, 'database': {'regex': {'regex': '\\\\s\\\\*\\\\sDatabase:(.*)', 'group_index': 0}, 'required': True, 'format': ' * Database: <database>', 'possible_values': ['clickhouse', 'postgres'], 'documentation_name': 'Database'}, 'output': {'regex': {'regex': '(\\\\s\\\\*\\\\sOutput:\\\\n\\\\s\\\\*\\\\s-+\\\\n((\\\\s\\\\*\\\\s-\\\\s\\\\w+:\\\\s.*\\\\n?)+))', 'group_index': 1}, 'required': True, 'documentation_name': 'Output'}, 'depends': {'regex': {'regex': '(\\\\s\\\\*\\\\sDepends:\\\\n\\\\s\\\\*\\\\s-+\\\\n((\\\\s\\\\*\\\\s-\\\\s.+:\\\\s.*\\\\n?)+))', 'group_index': 1}, 'required': False, 'documentation_name': 'Depends'}, 'other': {'regex': {'regex': '(\\\\s\\\\* (.+?):\\\\n\\\\s\\\\*\\\\s-+\\\\n((?:(?!^\\\\s*\\\\*\\\\s*\\\\n)\\\\s\\\\*\\\\s.*\\\\n)+))', 'group_index': 2}, 'required': False, 'documentation_name': 'Other'}}"}, {"fullname": "queries.query.ignore_types_in_prepare_query", "modulename": "queries.query", "qualname": "ignore_types_in_prepare_query", "kind": "variable", "doc": "

List of keywords that need to be before the parameter in the query\nto ignore the type of the parameter.\nFor example when the parameter is a string, the query should look like:\nSELECT * FROM table WHERE column = '<parameter_value>'\nIf the parameter is a string but it is after one of the keywords in the list,\nthe query should look like:

\n\n

SELECT * FROM <parameter_value> (without '')
INSERT INTO <parameter_value> (without '')
CREATE TABLE <parameter_value> (without '')

\n\n

You must use capital letters on these keywords in order for this library \nto work.

\n", "default_value": "['FROM', 'TABLE', 'INTO']"}, {"fullname": "queries.query.Query", "modulename": "queries.query", "qualname": "Query", "kind": "class", "doc": "

\n"}, {"fullname": "queries.query.Query.__init__", "modulename": "queries.query", "qualname": "Query.__init__", "kind": "function", "doc": "

This class represents a query that can be run on a database.\nThe query can be run on ClickHouse or Postgres database.

\n\n

This class is written for fast execution of queries because of use\nof asyncio and threading.

\n\n

The main idea is that the query is prepared only once and then\nit is\nrun on the database. The query can be run synchronously or\nasynchronously.

\n\n

The query can have input parameters that are replaced in the query\nbefore running the query.

\n\n

The query can have output that is checked if it matches the\ncolumns in the results.

\n\n

Other information that can be used in the child classes and use cases\ncan be set using the other parameter.

\n\n

The query can have dependencies on other queries. The\ndependencies are\nused for other libraries and are not used in this library.

\n\n

Arguments:

\n\n

name (str): name of the query
author (str): author of the query
database (str): database on which the query is run
date (str): date when the query was created
output (dict): output of the query in format: {'': ''}
input_parameters (dict): input parameters of the query (default: None), for example: {'': ''}
depends (dict): dependencies of the query (default: None) in format: {'': }
other (dict): other information about the query (default: None)

\n", "signature": "(\tquery: str,\tname: str,\tauthor: str,\tdatabase: str,\tdate: str,\toutput: dict = None,\tinput_parameters: dict = None,\tdepends: dict = None,\tother: dict = None)"}, {"fullname": "queries.query.Query.number_of_dependent", "modulename": "queries.query", "qualname": "Query.number_of_dependent", "kind": "function", "doc": "

This method returns the number of dependent queries.

\n\n

Returns:

\n\n

\n
int: Number of dependent queries.
\n

\n", "signature": "(self) -> int:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_dependent", "modulename": "queries.query", "qualname": "Query.get_dependent", "kind": "function", "doc": "

This method returns the dependent queries names.

\n\n

Will return an empty list if there are no dependent queries.

\n\n

Returns:

\n\n

\n
list[str]: List of names of dependent queries.
\n

\n", "signature": "(self) -> list[str]:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_output", "modulename": "queries.query", "qualname": "Query.get_output", "kind": "function", "doc": "

This method returns the list of output column names.

\n\n

Returns:

\n\n

\n
list[str]: List of output column names .
\n

\n", "signature": "(self) -> list[str]:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_documentation_other", "modulename": "queries.query", "qualname": "Query.get_documentation_other", "kind": "function", "doc": "

This method returns the other information about the query from\ndocumentation.

\n\n

Returns:

\n\n

\n
dict: Other information about the query
\n

\n", "signature": "(self) -> dict:", "funcdef": "def"}, {"fullname": "queries.query.Query.run_query", "modulename": "queries.query", "qualname": "Query.run_query", "kind": "function", "doc": "

This method runs the query on the database.\nThe method prepares the query and then runs the query on the database.

\n\n

The method raises a ValueError if the output columns do not match with\nthe columns in the results.

\n\n

If the output is not defined, the method will return an empty\nDataFrame.\nIf output is empty but the results are fetched, the method will raise a\nUserWarning.

\n\n

Arguments:

\n\n

host (str): Host of the database.
port (str): Port of the database.
user (str): User of the database.
password (str): Password of the database.
database (str): Database name.
**kwargs: input parameters for the query

\n\n

Returns:

\n\n

\n
pd.DataFrame: Results of the query (can be empty if no results were fetched).
\n

\n", "signature": "(\tself,\thost: str = None,\tport: str = None,\tuser: str = None,\tpassword: str = None,\tdatabase: str = None,\t**kwargs) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, {"fullname": "queries.query.Query.run_query_async", "modulename": "queries.query", "qualname": "Query.run_query_async", "kind": "function", "doc": "

This method runs the query on the database asynchronously.\nThe method prepares the query and then runs the query on the database.

\n\n

The method raises a ValueError if the output columns do not match with\nthe columns in the results.

\n\n

\n
It is important to have in mind that each call of this method\n creates a separate connection to the database. Too much of open\n connections to the database can result in Exceptions. So the use of\n Semaphores is recommended.
\n

\n\n

\n
The use of Semaphores is recommended when running multiple\n queries asynchronously.
\n

\n\n

Arguments:

\n\n

semaphore (asyncio.Semaphore): Semaphore for running the query asynchronously.
host (str): Host of the database.
port (str): Port of the database.
user (str): User of the database.
password (str): Password of the database.
database (str): Database name.
**kwargs: input parameters for the query

\n\n

Returns:

\n\n

\n
pd.DataFrame: Results of the query (can be empty if no results were fetched).
\n

\n", "signature": "(\tself,\tsemaphore: asyncio.locks.Semaphore = None,\thost: str = None,\tport: str = None,\tuser: str = None,\tpassword: str = None,\tdatabase: str = None,\t**kwargs) -> pandas.core.frame.DataFrame:", "funcdef": "async def"}, {"fullname": "queries.query.Query.get_results", "modulename": "queries.query", "qualname": "Query.get_results", "kind": "function", "doc": "

Returns the results of the query.

\n\n

Returns:

\n\n

\n
pd.DataFrame: Results of the query (can be empty if no results were fetched).
\n

\n", "signature": "(self) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_results_async", "modulename": "queries.query", "qualname": "Query.get_results_async", "kind": "function", "doc": "

Returns the results of the query asynchronously.

\n\n

Returns:

\n\n

\n
pd.DataFrame: Results of the query (can be empty if no results were fetched).
\n

\n", "signature": "(self) -> pandas.core.frame.DataFrame:", "funcdef": "async def"}, {"fullname": "queries.query.Query.get_name", "modulename": "queries.query", "qualname": "Query.get_name", "kind": "function", "doc": "

Returns the name of the query.

\n\n

Returns:

\n\n

\n
str: Name of the query.
\n

\n", "signature": "(self) -> str:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_database", "modulename": "queries.query", "qualname": "Query.get_database", "kind": "function", "doc": "

Returns the database on which the query is run.

\n\n

Returns:

\n\n

\n
str: Database on which the query is run.
\n

\n", "signature": "(self) -> str:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_input_parameters", "modulename": "queries.query", "qualname": "Query.get_input_parameters", "kind": "function", "doc": "

Returns the input parameters of the query.\nThis method returns the input parameters in the following format:

\n\n

{\n    <input_name>: <input_description>\n}\n

\n\n

Input parameters can be empty, so method can return None.

\n\n

Returns:

\n\n

\n
dict | None: Input parameters of the query.
\n

\n", "signature": "(self) -> dict[str, str] | None:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_date", "modulename": "queries.query", "qualname": "Query.get_date", "kind": "function", "doc": "

Returns the date when the query was created.

\n\n

Returns:

\n\n

\n
datetime.datetime: Date when the query was created.
\n

\n", "signature": "(self) -> datetime.datetime:", "funcdef": "def"}, {"fullname": "queries.query.Query.get_query", "modulename": "queries.query", "qualname": "Query.get_query", "kind": "function", "doc": "

Returns the query.

\n\n

Returns:

\n\n

\n
str: Query.
\n

\n", "signature": "(self) -> str:", "funcdef": "def"}, {"fullname": "queries.query.get_format", "modulename": "queries.query", "qualname": "get_format", "kind": "function", "doc": "

This function extracts the information from the query and returns\nthe Query object.

\n\n

The following rules must apply to the query:

\n\n

The query must be in the following format:

\n\n

/* <parameters> */\n<query>\n

\n\n

The query must contain the following parameters:\n
- name - name of the query
- author - author of the query
- date - date when the query was created
- database - database on which the query is run (clickhouse or\npostgres)
- output - output of the query
The query can contain the following parameters:
\n\n
- input_parameters - input parameters of the query
- depends - dependencies of the query (implementation used in other\nlibraries)
- other - contains the list of entires in the following\nformat:
\n\n
```
<env_name>:\n-----------\n- <anything>\n- <anything>\n
```

\n\n

Template for the query:

\n\n

/*\n * ============================================================================\n * SQL Query: <query name>\n * ============================================================================\n *\n * Author: <query author>\n * Date: <date in format %Y-%m-%d>\n * Database: <database name, clickhouse or postgres>\n *\n *\n * Input Parameters:\n * -----------------\n * - :<input name>: <input description>\n *\n * Output:\n * -------\n * - <output column>: <description of output column>\n *\n * Depends:\n * -------\n * - <table depend on name>: <table depends on description>\n *\n *\n *\n * <any name other then specified in this example>:\n * -------\n * - <value>\n * - <value>\n *\n * ============================================================================\n */\nSELECT *\nFROM :<input name>;\n

\n\n

BE CAREFUL!

\n\n

\n
If you have anywhere input parameter prefix in a query, that prefix\n will be replaced with input variable value.\n To be specific, every part of query that has the following format:\n :<input_variable_name>... will be replaced with:\n <input_variable_value>....
\n

\n\n

\n
Dynamic querying of a source database is only possible in clickhouse,\n because Postgres must reference one database on initialization,\n we can\u2019t choose the database after we initialized the object.\n That means that you can use the following format in a query only\n if you are using clickhouse:
\n

\n\n

/* ... */\nSELECT *\nFROM :database.table1\n

\n\n

\n
It is good practice to have SQL keywords in capital letters. This\n library requires you to have all capital letters on keywords defined\n in ignore_types_in_prepare_query.
\n

\n\n

Arguments:

\n\n

query (str): Query string.

\n\n

Returns:

\n\n

\n
Query: Query object.
\n

\n", "signature": "(query) -> queries.query.Query:", "funcdef": "def"}, {"fullname": "queries.query.Queries", "modulename": "queries.query", "qualname": "Queries", "kind": "class", "doc": "

This class represents a collection of queries.\nThe queries can be run synchronously or asynchronously.

\n\n

You can select Query or subset of Query in Queries by using\n__getitem__ method.

\n\n

If the given ite, is an integer, the method returns the Query object (\nbased on position in the collection).\nIf the item is a slice, the method returns the Queries object with\nthe subset of queries.\nIf the item is a string, the method returns the Query object with\nthe name of the query.

\n\n

You can also provide slices with integers or datetime.datetime objects.

\n\n

\n
In the case of slices, you will get the subset of queries based on\n the position in the collection or based on the date of the query.\n Resulting Queries object will have the same order of queries as in\n the original collection also it will be a copy of the original
\n

\n\n

For example:

\n\n

from queries.query import Queries\n\nqueries = Queries('path_to_file')\nquery = queries[0]\nsubset = queries[1:3]\nquery = queries['query_name']\nquery = queries[datetime.datetime(2021, 1, 1):datetime.datetime(2021, 1, 2)]\n

\n\n

Another good thing about this library is that you can use addition to\ncombine multiple Queries objects and get one.

\n\n

from queries.query import Queries\n\nqueries1 = Queries('path_to_file1')\nqueries2 = Queries('path_to_file2')\nqueries = queries1 + queries2\n

\n\n

As you can see, you can use the + operator to combine multiple\nQueries objects, but you can also use the += operator to add\nmultiple Queries objects to the original Queries object.

\n\n

from queries.query import Queries\n\nqueries = Queries('path_to_file1')\nqueries += Queries('path_to_file2')\n

\n\n

The order of the output Queries is not specified, and after\ncalling this method path is set to None. For more information look\nat __add__ method.

\n\n

You can also subtract Queries objects from the original Queries\nobject. The result is the Queries object with the queries that are\nin the original Queries object but not in the subtracted Queries\nobject.

\n\n

from queries.query import Queries\n\nqueries = Queries('path_to_file1')\nqueries -= Queries('path_to_file2')\n

\n\n

You can also use the - to subtract Query objects from the original\nQueries object. The result is the Queries object with the queries\nthat are in the original Queries object but not in the subtracted\nQuery object.

\n\n

from queries.query import Queries\n\nqueries = Queries('path_to_file1')\nqueries -= queries[0]\n

\n\n

For more information look at __sub__ method.

\n"}, {"fullname": "queries.query.Queries.__init__", "modulename": "queries.query", "qualname": "Queries.__init__", "kind": "function", "doc": "

This class represents a collection of queries.\nThe queries can be run synchronously or asynchronously.

\n\n

Constructor recieves the path to the file or directory with queries.\nThe queries are loaded from the file or directory and stored in the\ndictionary.

\n\n

If the path is a directory, the class will load all .sql files from\nthe directory.

\n\n

If path is not existing, the class will raise a ValueError.\nIf the file is not a SQL file (doesn't end with .sql), object\nraises a ValueError.

\n\n

If the file is empty, the method raises a ValueError.\nIf there are multiple queries with the same name detected, the method\nraises a ValueError.

\n\n

You can pass a path to the config file with different environment\nvariables. The config file has to be a JSON file.

\n\n

\n
Later you can define running environment from config file based on\n the parameter you send when calling a method that runs a query.
\n

\n\n

Arguments:

\n\n

source (str | list[str] | Query | list[Query]): path to the file or directory with queries or list of paths to the files or directories or Query object or list of Query objects
n_workers (int): number of workers for running queries in parallel
env_config_file (str): path to the config file with different environment variables

\n", "signature": "(\tsource: str | list[str] | queries.query.Query | list[queries.query.Query],\tn_workers: int = None,\tenv_config_file: str = None)"}, {"fullname": "queries.query.Queries.path", "modulename": "queries.query", "qualname": "Queries.path", "kind": "variable", "doc": "

Path to the file or directory with queries.

\n"}, {"fullname": "queries.query.Queries.env_config_file", "modulename": "queries.query", "qualname": "Queries.env_config_file", "kind": "variable", "doc": "

Path to the config file with different environment variables.

\n"}, {"fullname": "queries.query.Queries.env_configuration", "modulename": "queries.query", "qualname": "Queries.env_configuration", "kind": "variable", "doc": "

Configuration from the env config file.

\n"}, {"fullname": "queries.query.Queries.run_queries", "modulename": "queries.query", "qualname": "Queries.run_queries", "kind": "function", "doc": "

This method runs all queries in the collection, synchronously.

\n\n

If there is an error in the query, the method raises a ValueError.

\n\n

Example of usage:

\n\n

from queries.query import Queries\n\nqueries = Queries('path_to_file')\nresults = queries.run_queries(input_name='value')\n

\n\n

Arguments:

\n\n

env_name (str): name of the environment from the config file
**kwargs: input parameters for the queries

\n\n

Returns:

\n\n

\n
dict: Dictionary with the results of the queries. The key is the name of the query and the value is the result of the query.
\n

\n", "signature": "(\tself,\tenv_name: str = None,\t**kwargs) -> dict[str, pandas.core.frame.DataFrame]:", "funcdef": "def"}, {"fullname": "queries.query.Queries.run_queries_async", "modulename": "queries.query", "qualname": "Queries.run_queries_async", "kind": "function", "doc": "

This method runs all queries in the collection, asynchronously.

\n\n

If there is an error in the query, the method raises a ValueError.

\n\n

Example of usage:

\n\n

import asyncio\nfrom queries.query import Queries\n\nqueries = Queries('path_to_file')\nresults = asyncio.run(queries.run_queries_async(input_name='value'))\n

\n\n

Arguments:

\n\n

env_name (str): name of the environment from the config file
**kwargs: input parameters for the queries

\n\n

Returns:

\n\n

\n
dict: Dictionary with the results of the queries. The key is the name of the query and the value is the result of the query.
\n

\n", "signature": "(\tself,\tenv_name: str = None,\t**kwargs) -> dict[str, pandas.core.frame.DataFrame]:", "funcdef": "async def"}, {"fullname": "queries.query.Queries.run_query_specific", "modulename": "queries.query", "qualname": "Queries.run_query_specific", "kind": "function", "doc": "

This method runs a specific query from the collection.\nYou need to provide the name of the query.

\n\n

If provided query name does not exist in the collection, the method\nraises a ValueError.

\n\n

Arguments:

\n\n

query_name (str): name of the query
env_name (str): name of the environment from the config file
**kwargs: input parameters for the query

\n\n

Returns:

\n\n

\n
pd.DataFrame: Results of the query.
\n

\n", "signature": "(\tself,\tquery_name: str,\tenv_name: str = None,\t**kwargs) -> pandas.core.frame.DataFrame:", "funcdef": "def"}, {"fullname": "queries.query.Queries.run_query_specific_async", "modulename": "queries.query", "qualname": "Queries.run_query_specific_async", "kind": "function", "doc": "

This method runs a specific query from the collection asynchronously.\nYou need to provide the name of the query.

\n\n

If provided query name does not exist in the collection, the method\nraises a ValueError.

\n\n

This method uses the semaphore for running the query asynchronously.

\n\n

Arguments:

\n\n

query_name (str): name of the query
env_name (str): name of the environment from the config file
**kwargs: input parameters for the query

\n\n

Returns:

\n\n

\n
pd.DataFrame: Results of the query.
\n

\n", "signature": "(\tself,\tquery_name: str,\tenv_name: str = None,\t**kwargs) -> pandas.core.frame.DataFrame:", "funcdef": "async def"}, {"fullname": "queries.query.Queries.run_subset_queries", "modulename": "queries.query", "qualname": "Queries.run_subset_queries", "kind": "function", "doc": "

This method runs a subset of queries from the collection.\nYou need to provide the list of query names.

\n\n

If provided query names do not exist in the collection, the method\nraises a ValueError.

\n\n

Arguments:

\n\n

query_names (list): list of query names
env_name (str): name of the environment from the config file
**kwargs: input parameters for the queries

\n\n

Returns:

\n\n

\n
dict: Dictionary with the results of the queries. The key is the name of the query and the value is the result of the query.
\n

\n", "signature": "(\tself,\tquery_names: list[str],\tenv_name: str = None,\t**kwargs) -> dict[str, pandas.core.frame.DataFrame]:", "funcdef": "def"}, {"fullname": "queries.query.Queries.run_subset_queries_async", "modulename": "queries.query", "qualname": "Queries.run_subset_queries_async", "kind": "function", "doc": "

This method runs a subset of queries from the collection asynchronously.\nYou need to provide the list of query names.

\n\n

If provided query names do not exist in the collection, the method\nraises a ValueError.

\n\n

Arguments:

\n\n

query_names (list): list of query names
env_name (str): name of the environment from the config file
**kwargs: input parameters for the queries

\n\n

Returns:

\n\n

\n
dict: Dictionary with the results of the queries. The key is the name of the query and the value is the result of the query.
\n

\n", "signature": "(\tself,\tquery_names: list[str],\tenv_name: str = None,\t**kwargs) -> dict[str, pandas.core.frame.DataFrame]:", "funcdef": "async def"}, {"fullname": "queries.query.Queries.add", "modulename": "queries.query", "qualname": "Queries.add", "kind": "function", "doc": "

This method adds a query to the collection.

\n\n

If the query with the same name already exists in the collection,\nthe method raises a ValueError.

\n\n

Arguments:

\n\n

query (Query): Query object to add to the collection.

\n", "signature": "(self, query: queries.query.Query) -> None:", "funcdef": "def"}, {"fullname": "queries.query.Queries.pop", "modulename": "queries.query", "qualname": "Queries.pop", "kind": "function", "doc": "

This method removes the query from the collection and returns it.

\n\n

If the query with the name does not exist in the collection, the\nmethod raises a ValueError.

\n\n

You can provide a list of query names to remove multiple queries.

\n\n

Arguments:

\n\n

query (str | list[str]): name of the query, or list of names

\n\n

Returns:

\n\n

\n
Query | list[Query]: Query object or list of Query objects
\n

\n", "signature": "(\tself,\tquery: str | list[str]) -> queries.query.Query | list[queries.query.Query]:", "funcdef": "def"}, {"fullname": "queries.query.Queries.get_queries", "modulename": "queries.query", "qualname": "Queries.get_queries", "kind": "function", "doc": "

This method returns the queries in dictionary format.

\n\n

Returns:

\n\n

\n
dict[str, Query]: Dictionary with queries.
\n

\n", "signature": "(self) -> dict[str, queries.query.Query]:", "funcdef": "def"}, {"fullname": "queries.query.Queries.keys", "modulename": "queries.query", "qualname": "Queries.keys", "kind": "function", "doc": "

This method returns the names of the queries.

\n\n

Returns:

\n\n

\n
list[str]: List of names of the queries.
\n

\n", "signature": "(self) -> list[str]:", "funcdef": "def"}, {"fullname": "queries.query.Queries.reorder_queries", "modulename": "queries.query", "qualname": "Queries.reorder_queries", "kind": "function", "doc": "

This method reorders the queries in the collection.\nYou need to provide the list of query names in the new order.

\n\n

Arguments:

\n\n

query_names (list): List of query names in the new order.

\n", "signature": "(self, query_names: list[str]) -> None:", "funcdef": "def"}, {"fullname": "queries.query.Queries.set_number_of_workers", "modulename": "queries.query", "qualname": "Queries.set_number_of_workers", "kind": "function", "doc": "

This method sets the number of workers for running queries in parallel.

\n\n

Arguments:

\n\n

n_workers (int): Number of workers for running queries in parallel.

\n", "signature": "(self, n_workers: int) -> None:", "funcdef": "def"}, {"fullname": "queries.query.Queries.get_number_of_workers", "modulename": "queries.query", "qualname": "Queries.get_number_of_workers", "kind": "function", "doc": "

This method returns the number of workers for running queries\nin parallel.

\n\n

Returns:

\n\n

\n
int: Number of workers for running queries in parallel.
\n

\n", "signature": "(self) -> int:", "funcdef": "def"}]; // mirrored in build-search-index.js (part 1) // Also split on html tags. this is a cheap heuristic, but good enough. elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); let searchIndex; if (docs._isPrebuiltIndex) { console.info("using precompiled search index"); searchIndex = elasticlunr.Index.load(docs); } else { console.time("building search index"); // mirrored in build-search-index.js (part 2) searchIndex = elasticlunr(function () { this.pipeline.remove(elasticlunr.stemmer); this.pipeline.remove(elasticlunr.stopWordFilter); this.addField("qualname"); this.addField("fullname"); this.addField("annotation"); this.addField("default_value"); this.addField("signature"); this.addField("bases"); this.addField("doc"); this.setRef("fullname"); }); for (let doc of docs) { searchIndex.addDoc(doc); } console.timeEnd("building search index"); } return (term) => searchIndex.search(term, { fields: { qualname: {boost: 4}, fullname: {boost: 2}, annotation: {boost: 2}, default_value: {boost: 2}, signature: {boost: 2}, bases: {boost: 2}, doc: {boost: 1}, }, expand: true }); })();