tellaro-query-language 0.1.0__py3-none-any.whl

tellaro_query_language-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tellaro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tellaro_query_language-0.1.0.dist-info/METADATA

@@ -0,0 +1,401 @@
+Metadata-Version: 2.1
+Name: tellaro-query-language
+Version: 0.1.0
+Summary: A flexible, human-friendly query language for searching and filtering structured data
+Home-page: https://github.com/tellaro/tellaro-query-language
+License: MIT
+Keywords: query,language,opensearch,elasticsearch,search,filter,tql
+Author: Justin Henderson
+Author-email: justin@tellaro.io
+Requires-Python: >=3.11,<3.14
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Provides-Extra: opensearch
+Requires-Dist: dnspython (>=2.7.0,<3.0.0)
+Requires-Dist: maxminddb (>=2.7.0,<3.0.0)
+Requires-Dist: opensearch-dsl (>=2.1.0,<3.0.0) ; extra == "opensearch"
+Requires-Dist: opensearch-py (>=2.4.2,<3.0.0) ; extra == "opensearch"
+Requires-Dist: pyparsing (>=3.2.1,<4.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0) ; extra == "opensearch"
+Requires-Dist: setuptools (>=80.0.0,<81.0.0)
+Project-URL: Documentation, https://github.com/tellaro/tellaro-query-language/tree/main/docs
+Project-URL: Repository, https://github.com/tellaro/tellaro-query-language
+Description-Content-Type: text/markdown
+
+# Tellaro Query Language
+
+[![PyPI version](https://badge.fury.io/py/tellaro-query-language.svg)](https://badge.fury.io/py/tellaro-query-language)
+[![Tests Status](./badges/test-badge.svg?dummy=8484744)](./reports/pytest/junit.xml) [![Coverage Status](./badges/coverage-badge.svg?dummy=8484744)](./reports/coverage/index.html) [![Flake8 Status](./badges/flake8-badge.svg?dummy=8484744)](./reports/flake8/index.html)
+[![Python 3.11-3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What is TQL?
+
+Tellaro Query Language (TQL) is a flexible, human-friendly query language for searching and filtering structured data. TQL is designed to provide a unified, readable syntax for expressing complex queries, supporting both simple and advanced search scenarios. It is especially useful for environments where data may come from different backends (such as OpenSearch or JSON files) and where users want to write queries that are portable and easy to understand.
+
+TQL supports:
+- **Field selection** (including nested fields)
+- **Comparison and logical operators**
+- **String, number, and list values**
+- **Collection operators** (ANY, ALL) for working with list fields
+- **Mutators** for post-processing or transforming field values
+- **Operator precedence and parenthetical grouping** (AND, OR, NOT, etc.)
+- **Field extraction** for analyzing query dependencies
+- **Multiple backends** (in-memory evaluation, OpenSearch, file operations)
+- **Statistical aggregations** for data analysis
+
+---
+
+## TQL Syntax Overview
+
+### Basic Query Structure
+
+TQL queries are generally structured as:
+
+```
+field [| mutator1 | mutator2 ...] operator value
+```
+
+- **field**: The field to query (e.g., `computer.name`, `os.ver`).
+- **mutator**: (Optional) One or more transformations to apply to the field before comparison (e.g., `| lowercase`).
+- **operator**: The comparison operator (e.g., `eq`, `contains`, `in`, `>`, `regexp`).
+- **value**: The value to compare against (string, number, identifier, or list).
+
+#### Example
+
+```
+computer.name | lowercase eq 'ha-jhend'
+os.ver > 10
+os.dataset in ['windows_server', 'enterprise desktop']
+```
+
+### Mutators
+
+Mutators allow you to transform field values before comparison. For example, `| lowercase` will convert the field value to lowercase before evaluating the condition.
+
+```
+user.email | lowercase eq 'admin@example.com'
+```
+
+### Operators
+
+TQL supports a variety of comparison operators, including:
+
+- `eq`, `=`, `ne`, `!=` (equals, not equals)
+- `>`, `>=`, `<`, `<=` (greater/less than)
+- `contains`, `in`, `regexp`, `startswith`, `endswith`
+- `is`, `exists`, `range`, `between`, `cidr`
+
+### Values
+
+Values can be:
+- **Strings**: `'value'` or `"value"`
+- **Numbers**: `123`, `42`, `1.01`
+- **Identifiers**: `computer01`, `admin`
+- **Lists**: `["val1", "val2"]`
+
+### Logical Expressions
+
+TQL supports logical operators and grouping:
+
+```
+field1 eq 'foo' AND (field2 > 10 OR field3 in ['a', 'b'])
+NOT field4 contains 'bar'
+```
+
+Operators supported: `AND`, `OR`, `NOT`, `ANY`, `ALL` (case-insensitive)
+
+### Example Query
+
+```
+computer.name | lowercase eq 'ha-jhend' AND (os.ver > 10 OR os.dataset in ['windows_server', 'enterprise desktop'])
+```
+
+---
+
+## Why TQL Matters
+
+TQL provides a consistent, readable way to express queries across different data sources. It abstracts away backend-specific quirks (like OpenSearch's text vs. keyword fields) and lets users focus on what they want to find, not how to write backend-specific queries.
+
+**Key benefits:**
+- **Unified syntax**: Write one query, run it on many backends.
+- **Mutators**: Easily transform data inline (e.g., lowercase, trim).
+- **Readability**: Queries are easy to read and write, even for complex logic.
+- **Extensible**: New operators and mutators can be added as needed.
+
+---
+
+## Example: TQL in Action
+
+Suppose you want to find computers named "HA-JHEND" (case-insensitive), running Windows Server or Enterprise Desktop, and with an OS version greater than 10:
+
+```
+computer.name | lowercase eq 'ha-jhend' AND (os.ver > 10 OR os.dataset in ['windows_server', 'enterprise desktop'])
+```
+
+This query will:
+- Convert `computer.name` to lowercase and compare to `'ha-jhend'`
+- Check if `os.ver` is greater than 10
+- Check if `os.dataset` is in the provided list
+
+---
+
+## Implementation Notes
+
+TQL is implemented using [pyparsing](https://pyparsing-docs.readthedocs.io/en/latest/) to define the grammar and parse queries. The parser supports mutators, operator precedence, and both standard and reversed operator forms (e.g., `'value' in field`).
+
+See `src/tql/` for the implementation, including the parser grammar and evaluation logic.
+
+## Documentation
+
+For comprehensive documentation, see the [`docs/`](./docs/) folder:
+
+- **[Getting Started](./docs/getting-started.md)** - Learn TQL basics with development examples
+- **[Development Guide](./docs/development-guide.md)** - File operations, testing, and common patterns
+- **[OpenSearch Integration](./docs/opensearch-integration.md)** - Convert TQL to OpenSearch DSL and Lucene queries
+- **[Syntax Reference](./docs/syntax-reference.md)** - Complete grammar and syntax specification  
+- **[Operators](./docs/operators.md)** - All comparison and logical operators
+- **[Mutators](./docs/mutators.md)** - Field transformation functions (25+ mutators available)
+- **[Stats & Aggregations](./docs/stats.md)** - Statistical analysis and data aggregation functions
+- **[Examples](./docs/examples.md)** - Real-world query examples for security, DevOps, and business use cases
+- **[Best Practices](./docs/best-practices.md)** - Performance optimization and maintainability tips
+
+## Quick Start
+
+### Installation
+
+```bash
+# Install from PyPI
+pip install tellaro-query-language
+
+# Or install with OpenSearch support
+pip install tellaro-query-language[opensearch]
+```
+
+### Basic Usage
+
+```python
+from tql import TQL
+
+# Initialize TQL
+tql = TQL()
+
+# Query data
+data = [{'name': 'Alice', 'age': 30}, {'name': 'Bob', 'age': 25}]
+results = tql.query(data, 'age > 27')
+print(f'Found {len(results)} people over 27: {results}')
+# Output: Found 1 people over 27: [{'name': 'Alice', 'age': 30}]
+```
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/tellaro/tellaro-query-language.git
+cd tellaro-query-language
+
+# Install with poetry
+poetry install
+
+# Run tests
+poetry run tests
+```
+
+### File Operations
+
+```python
+from src.tql import TQL
+
+# Query JSON files directly
+tql = TQL()
+results = tql.query("data.json", "user.role eq 'admin' AND status eq 'active'")
+
+# Query with field mappings for OpenSearch
+mappings = {"hostname": "agent.name.keyword"}
+tql_mapped = TQL(mappings)
+opensearch_dsl = tql_mapped.to_opensearch("hostname eq 'server01'")
+
+# Extract fields from a complex query
+query = "process.name eq 'explorer.exe' AND (user.id eq 'admin' OR user.groups contains 'administrators')"
+fields = tql.extract_fields(query)
+print(fields)  # ['process.name', 'user.groups', 'user.id']
+```
+
+### Query Analysis and Health Evaluation
+
+TQL provides context-aware query analysis to help you understand performance implications before execution:
+
+```python
+from src.tql import TQL
+
+tql = TQL()
+
+# Analyze for in-memory execution (default)
+query = "field | lowercase | trim eq 'test'"
+analysis = tql.analyze_query(query)  # or explicitly: analyze_query(query, context="in_memory")
+
+print(f"Health: {analysis['health']['status']}")  # 'good' - fast mutators don't impact in-memory
+print(f"Score: {analysis['health']['score']}")    # 100
+print(f"Has mutators: {analysis['stats']['has_mutators']}")  # True
+
+# Analyze the same query for OpenSearch execution
+analysis = tql.analyze_query(query, context="opensearch")
+print(f"Health: {analysis['health']['status']}")  # 'fair' - post-processing required
+print(f"Score: {analysis['health']['score']}")    # 85
+
+# Check mutator-specific health
+if 'mutator_health' in analysis:
+    print(f"Mutator health: {analysis['mutator_health']['health_status']}")
+    for reason in analysis['mutator_health']['health_reasons']:
+        print(f"  - {reason['reason']}")
+
+# Slow mutators impact both contexts
+slow_query = "hostname | nslookup contains 'example.com'"
+analysis = tql.analyze_query(slow_query)
+print(f"In-memory health: {analysis['health']['status']}")  # 'fair' or 'poor' - network I/O
+
+# Query complexity analysis
+complex_query = "(a > 1 OR b < 2) AND (c = 3 OR (d = 4 AND e = 5))"
+analysis = tql.analyze_query(complex_query)
+print(f"Depth: {analysis['complexity']['depth']}")
+print(f"Fields: {analysis['stats']['fields']}")
+print(f"Operators: {analysis['stats']['operators']}")
+```
+
+### Post-Processing with OpenSearch
+
+TQL intelligently handles mutators based on field mappings. When OpenSearch can't perform certain operations (like case-insensitive searches on keyword fields), TQL applies post-processing:
+
+```python
+# Field mappings with only keyword fields
+mappings = {"username": {"type": "keyword"}, "department": {"type": "keyword"}}
+tql = TQL(mappings)
+
+# This query requires post-processing since keyword fields can't do case-insensitive contains
+query = "username | lowercase contains 'admin' AND department eq 'Engineering'"
+
+# Analyze the query (analyze_opensearch_query is deprecated, use analyze_query instead)
+analysis = tql.analyze_query(query, context="opensearch")
+print(f"Health: {analysis['health']['status']}")  # 'fair' (post-processing required)
+
+# Execute with automatic post-processing
+result = tql.execute_opensearch(
+    opensearch_client=client,
+    index="users",
+    query=query
+)
+# OpenSearch returns all Engineering users, TQL filters to only those with 'admin' in username
+
+# Run the demo to see this in action
+# poetry run python post_processing_demo.py
+```
+
+### Development Examples
+
+```bash
+# Run comprehensive demos
+poetry run python demo.py                          # Basic functionality
+poetry run python intelligent_mapping_demo.py      # Field mapping features
+poetry run python test_requested_functionality.py  # Core functionality tests
+poetry run python field_extraction_demo.py         # Field extraction
+poetry run python post_processing_demo.py          # Post-processing filtering
+
+# Run tests
+poetry run pytest tests/ -v
+
+# Run integration tests with OpenSearch (requires OpenSearch)
+# 1. Copy .env.example to .env and configure connection settings
+# 2. Set OPENSEARCH_INTEGRATION_TEST=true in .env
+poetry run pytest tests/test_opensearch_integration.py -v
+```
+
+## Contributing
+
+TQL supports 25+ mutators including string manipulation, encoding/decoding, DNS operations, and network analysis. See the [Mutators documentation](./docs/mutators.md) for the complete list.
+
+To add new mutators or operators, see the implementation in `src/tql/mutators.py` and `src/tql/parser.py`.
+
+### Statistical Aggregations
+
+TQL supports powerful data analysis with stats expressions:
+
+```tql
+# Simple aggregation
+| stats sum(revenue)
+
+# Grouped analysis  
+| stats count(requests), average(response_time) by server_name
+
+# Top N analysis
+| stats sum(sales, top 10) by product_category
+
+# Complex analytics
+status eq 'success' 
+| stats count(requests), sum(bytes), average(response_time), max(cpu_usage) by endpoint
+```
+
+Stats functions include: `sum`, `min`, `max`, `count`, `unique_count`, `average`, `median`, `percentile_rank`, `zscore`, `std`
+
+## Documentation
+
+Comprehensive documentation is available in the [docs](./docs/) directory:
+
+- [**Getting Started**](./docs/getting-started.md) - Quick introduction to TQL
+- [**Syntax Reference**](./docs/syntax-reference.md) - Complete syntax guide
+- [**Operators**](./docs/operators.md) - All comparison and logical operators
+- [**Mutators**](./docs/mutators.md) - Field transformation functions
+- [**Mutator Caching & Security**](./docs/mutator-caching.md) - Performance optimization and security controls
+- [**OpenSearch Integration**](./docs/opensearch-integration.md) - Using TQL with OpenSearch
+- [**Examples**](./docs/examples.md) - Real-world query examples
+- [**Architecture**](./docs/architecture.md) - Modular architecture and design
+- [**Migration Guide**](./docs/migration-guide.md) - Upgrading from older versions
+
+## Development
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/tellaro/tellaro-query-language.git
+cd tellaro-query-language
+
+# Install with poetry
+poetry install
+
+# Or install with pip
+pip install -e .
+```
+
+### Testing
+
+This project supports Python 3.11, 3.12, 3.13, and 3.14. We use `nox` for automated testing across all versions.
+
+```bash
+# Install test dependencies
+poetry install --with dev
+
+# Run tests on all Python versions
+poetry run nox -s tests
+
+# Run tests on a specific version
+poetry run nox -s tests-3.12
+
+# Quick test run (fail fast, no coverage)
+poetry run nox -s test_quick
+
+# Run linting and formatting
+poetry run nox -s lint
+poetry run nox -s format
+
+# Run all checks
+poetry run nox -s all
+```
+
+For more detailed testing instructions, see [TESTING.md](TESTING.md).

tellaro_query_language-0.1.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+tql/__init__.py,sha256=mRrrtun-1Xx9k8g0aaiqxYhhNAwWEyRC4zrVMO49Kkg,1260
+tql/analyzer.py,sha256=Sfzj6f7YzqylT8HIL9hDbXdhl0lf8q8DNoafrxkD-F8,15456
+tql/cache/__init__.py,sha256=GIzIEMZUZEYJj72sAhuVLEG-OJEKUG2srUWNM3Ix-T8,213
+tql/cache/base.py,sha256=0b-8uyh3JltayGmXQI45snTqsM5sQu9u0KcNvZIRa-I,687
+tql/cache/memory.py,sha256=ibcmQSAxNvqCy6DksbU7gLu6UArYp1u3fW-oLubxtV0,2056
+tql/cache/redis.py,sha256=ZU_IsVDvpSYpNvPfnZ4iulJDODpEGx3c4dkXLzPzPVc,2309
+tql/core.py,sha256=HXz_95f9-yuBiI5iYGAPrpeqzokgSC5bsitOBLheuDU,37278
+tql/core_components/README.md,sha256=Rm7w4UHdQ0vPBEFybE5b62IOvSA5Nzq2GRvtBHOapmc,3068
+tql/core_components/__init__.py,sha256=v8BBybPlqV7dkVY9mw1mblvqyAFJZ7Pf_bEc-jAL7FI,643
+tql/core_components/file_operations.py,sha256=Jr0kkxz_OP2KHOAsIr7KMtYe_lbu8LuBUySt2LQbjJw,3925
+tql/core_components/opensearch_operations.py,sha256=x0GPdQfMX-NYCzzAlJCbtzYFa6HmaKxGEVl2JdAhKJY,35447
+tql/core_components/stats_operations.py,sha256=jNk7cQZLwwsIoN__hdFHME8e17AjDHYLvZ-5kwPxNUY,6853
+tql/core_components/validation_operations.py,sha256=_VPXh0HABBjsXF99jFT7B6-5QAPsADOCy6poinGrxeE,22454
+tql/evaluator.py,sha256=YdgS1vuxUEPAHhUsZey-Y4NydeS8CTYOy_O8R5_K8cE,15421
+tql/evaluator_components/README.md,sha256=c59yf2au34yPhrru7JWgGop_ORteB6w5vfMhsac8j3k,3882
+tql/evaluator_components/__init__.py,sha256=DourRUSYXWPnCghBFj7W0YfMeymT3X8YTDCwnLIyP1c,535
+tql/evaluator_components/field_access.py,sha256=BuXvL9jlv4H77neT70Vh7_qokmzs-d4EbSDA2FB1IT0,6435
+tql/evaluator_components/special_expressions.py,sha256=rC1klZRA6cXLeS14xBi5LYYMi0V1qU3yg6_B4etRRBs,12139
+tql/evaluator_components/value_comparison.py,sha256=A-RJ_52FLvsMO0ciEhJEdfhfFsoE4c3viNk7qYMFILI,15636
+tql/exceptions.py,sha256=hatIixXci6p57J9RrkfdvmKM_2i-JKb8ViL2kU4z7a8,5550
+tql/geoip_normalizer.py,sha256=tvie-5xevJEeLp2KmjoXDjYdND8AvyVE7lCO8qgUzGY,10486
+tql/mutator_analyzer.py,sha256=nCP64sVmEVV_zhpACfuTVTcuRV2NmypGbkWgS2taWOs,38039
+tql/mutators/__init__.py,sha256=zuzv6OMu2kVveDI85mu-6FA_-CZHsJEnIBIgtsjfXgY,6798
+tql/mutators/base.py,sha256=4Ze_x1sTO11OILXfcF2XN7ttyHcZ4gwn96UXFMMaC6M,2523
+tql/mutators/dns.py,sha256=Rmn6Kv-BmhfhMSYJ4GrkNmYms5rmpcxuG6leNxJspOQ,13387
+tql/mutators/encoding.py,sha256=yt12BJrHAIJfBesP8VOSfVlvJqB1yOmEeT_8QDPvNN8,7985
+tql/mutators/geo.py,sha256=fFQSg_Li3KjFKS3TI26yDzrDpWsmC3MfmgcsxYoQMgM,14507
+tql/mutators/list.py,sha256=949ZrKKhL4INkH2Od8bq7Ey80kFX_23PEfRKueG82cU,7084
+tql/mutators/network.py,sha256=1lZpmKt1GoTfNxiXUmSXkTwJIzPQZnQEgU7ojpBSm3A,5458
+tql/mutators/security.py,sha256=BE5x1IFCjq85UD22Q2sgSue_xXwhCk0umvf91a1XqJY,8202
+tql/mutators/string.py,sha256=8CzqZ2G5vpDeaEQ_jSA3NRidfUqfOrkUT9o2cmUUAEA,6288
+tql/opensearch.py,sha256=J7LhfVJfaXEWtyZqVDqNZaeIbIcUYJr2cQtfKzdyIhM,3362
+tql/opensearch_components/README.md,sha256=gt-qLmmach8Kh7-QwLZmoAxxIL79XIG1EDqJum8PMZE,3756
+tql/opensearch_components/__init__.py,sha256=_zIZY8Fns7mkEcY6w2p9FNRBXtEmmPFFJEcFRfrVyXA,514
+tql/opensearch_components/field_mapping.py,sha256=N4r7VkzNeXjIhNDt2cfnd1LbkvaS_9O298PIDAcR_Hw,17569
+tql/opensearch_components/lucene_converter.py,sha256=ZbupWZ2smGhWfE9cSIrNo7MZVY35l2t86HYM-bd7nKw,12436
+tql/opensearch_components/query_converter.py,sha256=9Nkhehb8X7jIQcyRaHCa5WCKWtovdRGKuSdDsBulrG0,36722
+tql/opensearch_mappings.py,sha256=zJCCdMrxK7mswrkxd5LiOhunQ9GIJNZdhktVoGXgVgk,11529
+tql/opensearch_stats.py,sha256=svcE23lD1gDe1iYGlC388WE8X3x9C8tjfBylUVy2Uqo,17216
+tql/parser.py,sha256=6WbCpMuYOJymSYHEgTFS7yTgCOPXsCmGsi9m_u5oQzc,73954
+tql/parser_components/README.md,sha256=lvQX72ckq2zyotGs8QIHHCIFqaA7bOHwkP44wU8Zoiw,2322
+tql/parser_components/__init__.py,sha256=zBwHBMPJyHSBbaOojf6qTrJYjJg5A6tPUE8nHFdRiQs,521
+tql/parser_components/ast_builder.py,sha256=-pbcYhZNoRm0AnjmJRAAlXLCAwHfauchTpX_6KO0plE,6793
+tql/parser_components/error_analyzer.py,sha256=qlCD9vKyW73aeKQYI33P1OjIWSJ3LPd08wuN9cis2fU,4012
+tql/parser_components/field_extractor.py,sha256=TumeuUo2c5gPYVbTPsmU43C3TJFC8chAAWERu5v_Q3c,4182
+tql/parser_components/grammar.py,sha256=bfThefrhdbCMPLWb9ZXwZDXx8ZW8_PXihjwCL-P3Gi8,18669
+tql/post_processor.py,sha256=-vA2wgbuLij2FVnj5I9HDHtw5bKj9Cu3EE9mtoeSWk8,28859
+tql/scripts.py,sha256=VOr5vCjIvKlW36kwvJx7JGFIRM16IJZlbJcWlBexBtk,3728
+tql/stats_evaluator.py,sha256=7ymCebPOepY3QKHGz0QEhkTmYYHjck648rrI8cWhhDI,15158
+tql/stats_transformer.py,sha256=MT-4rDWZSySgn4Fuq9H0c-mvwFYLM6FqWpPv2rHX-rE,7588
+tql/validators.py,sha256=e9MlX-zQ_O3M8YP8vXyMjKU8iiJMTh6mMK0iv0_4gTY,3771
+tellaro_query_language-0.1.0.dist-info/LICENSE,sha256=zRhQ85LnW55fWgAjQctckwQ67DX5Jmt64lq343ThZFU,1063
+tellaro_query_language-0.1.0.dist-info/METADATA,sha256=8C1D6P1nsAfTpWWEuRP43wCVLnV33jnUAR5LDV7MbRY,14567
+tellaro_query_language-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+tellaro_query_language-0.1.0.dist-info/entry_points.txt,sha256=H43APfGBMsZkKsUCnFTaqprQPW-Kce2yz2qsBL3dZrw,164
+tellaro_query_language-0.1.0.dist-info/RECORD,,

tellaro_query_language-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tellaro_query_language-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+badge=tql.scripts:run_badge
+cov=tql.scripts:run_coverage
+lint=tql.scripts:run_lint
+lint-all=tql.scripts:run_lint_all
+tests=tql.scripts:run_tests
+

tql/__init__.py

@@ -0,0 +1,47 @@
+"""Tellaro Query Language package.
+
+A flexible, human-friendly query language for searching and filtering structured data.
+TQL provides a unified syntax for expressing complex queries with support for:
+- Field selection (including nested fields)
+- Comparison and logical operators
+- String, number, and list values
+- Mutators for field transformation
+- Direct file operations and OpenSearch integration
+"""
+
+from .core import TQL
+from .exceptions import (
+    TQLExecutionError,
+    TQLFieldError,
+    TQLOperatorError,
+    TQLParseError,
+    TQLSyntaxError,
+    TQLTypeError,
+    TQLUnsupportedOperationError,
+    TQLValidationError,
+    TQLValueError,
+)
+from .opensearch import OpenSearchBackend
+from .opensearch_mappings import (
+    discover_field_mappings_for_query,
+    extract_field_mappings_from_opensearch,
+    get_sample_data_from_index,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "TQL",
+    "TQLParseError",
+    "TQLExecutionError",
+    "TQLValidationError",
+    "TQLSyntaxError",
+    "TQLTypeError",
+    "TQLFieldError",
+    "TQLOperatorError",
+    "TQLValueError",
+    "TQLUnsupportedOperationError",
+    "OpenSearchBackend",
+    "extract_field_mappings_from_opensearch",
+    "discover_field_mappings_for_query",
+    "get_sample_data_from_index",
+]