file_query_text 0.1.0__py3-none-any.whl

file_query_text/__init__.py

@@ -0,0 +1,3 @@
+"""SQL-like interface for querying files in your filesystem."""
+
+__version__ = "0.1.0"

file_query_text/cli.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+from pathlib import Path
+# Fix imports to work when installed as a package
+from file_query.main import parse_query, QueryVisitor, execute_query
+
+def main():
+    parser = argparse.ArgumentParser(description="SQL-like queries for your filesystem")
+    parser.add_argument("query", nargs="?", default="",
+                        help="SQL query for finding files (default: lists all files in current directory)")
+    parser.add_argument(
+        "--show-content", "-c",
+        action="store_true",
+        help="Display content of the matching files"
+    )
+    args = parser.parse_args()
+
+    # Get current working directory for the query
+    cwd = os.getcwd()
+
+    # Handle different query formats:
+    # 1. Full SQL format: "SELECT * FROM 'path' WHERE condition"
+    # 2. Simple condition: "extension == 'py'"
+    # 3. Simple path only: "SELECT * FROM 'path'"
+    # 4. Empty query: return all files in current directory
+    if not args.query.strip():
+        # Empty query - list all files in current directory
+        query_str = f"SELECT * FROM '{cwd}'"
+    elif args.query.strip().upper().startswith("SELECT"):
+        # Full SQL format or SELECT * FROM without WHERE - use as is
+        query_str = args.query
+    else:
+        # Simple condition format - assume it's a WHERE condition
+        query_str = f"SELECT * FROM '{cwd}' WHERE {args.query}"
+
+    # Parse and execute the query
+    parsed = parse_query(query_str)
+    if parsed:
+        visitor = QueryVisitor()
+        visitor.visit(parsed)
+        results = execute_query(visitor.select, visitor.from_dirs, visitor.where)
+
+        # Display results
+        if not results:
+            print("No matching files found.")
+            return
+
+        print(f"Found {len(results)} matching files:")
+        for file_path in results:
+            print(file_path)
+
+            # Optionally display file contents
+            if args.show_content:
+                try:
+                    with open(file_path, 'r') as f:
+                        content = f.read()
+                        print("\n--- File Content ---")
+                        print(content)
+                        print("--- End Content ---\n")
+                except Exception as e:
+                    print(f"Error reading file: {e}")
+
+if __name__ == "__main__":
+    main()

file_query_text/grammar.py

@@ -0,0 +1,63 @@
+from pyparsing import (
+    Word,
+    alphas,
+    alphanums,
+    QuotedString,
+    delimitedList,
+    Optional,
+    Group,
+    Suppress,
+    ZeroOrMore,
+    oneOf,
+    Forward,
+    Literal,
+    OneOrMore,
+    infixNotation,
+    opAssoc,
+    c_style_comment,
+    nums,
+    pyparsing_common,
+)
+
+# Define keywords
+SELECT = Suppress(Word("SELECT"))
+FROM = Suppress(Word("FROM"))
+WHERE = Suppress(Word("WHERE"))
+AND = Literal("AND")
+OR = Literal("OR")
+NOT = Literal("NOT")
+
+# Define identifiers and literals
+IDENTIFIER = Word(alphas + "_")
+STRING_LITERAL = QuotedString("'", unquoteResults=True)
+# Use pyparsing_common for numeric literals
+NUMERIC_LITERAL = pyparsing_common.integer
+DIRECTORY_LIST = Group(delimitedList(STRING_LITERAL))
+
+# Define comparison operators
+COMPARISON_OP = oneOf("== != < <= > >=")
+ATTRIBUTE = IDENTIFIER + Suppress("=") + STRING_LITERAL
+
+# Define basic condition with support for both string and numeric literals
+VALUE = STRING_LITERAL | NUMERIC_LITERAL
+basic_condition = Group(IDENTIFIER + COMPARISON_OP + VALUE)
+
+# Define logical expressions using infixNotation for better handling of AND and OR
+condition_expr = Forward()
+condition_expr <<= infixNotation(
+    basic_condition,
+    [
+        (NOT, 1, opAssoc.RIGHT),
+        (AND, 2, opAssoc.LEFT),
+        (OR, 2, opAssoc.LEFT),
+    ],
+)
+
+# Define the full query structure
+query = (
+    SELECT
+    + (Literal("*") | Group(OneOrMore(IDENTIFIER))).setResultsName("select")
+    + FROM
+    + DIRECTORY_LIST.setResultsName("from_dirs")
+    + Optional(WHERE + condition_expr.setResultsName("where"))
+)

file_query_text/main.py

@@ -0,0 +1,110 @@
+import os
+import sys
+from file_query_text.grammar import query  # Import the fixed grammar
+
+
+def parse_query(query_str):
+    try:
+        # Increase recursion limit temporarily to handle complex queries
+        old_limit = sys.getrecursionlimit()
+        sys.setrecursionlimit(2000)
+
+        parsed = query.parseString(query_str, parseAll=True)
+
+        # Restore original recursion limit
+        sys.setrecursionlimit(old_limit)
+        return parsed
+    except Exception as e:
+        print(f"Parse error: {e}")
+        return None
+
+class QueryVisitor:
+    def __init__(self):
+        self.select = []
+        self.from_dirs = []
+        self.where = None
+
+    def visit(self, parsed_query):
+        self.select = parsed_query.get("select", ["*"])
+        self.from_dirs = parsed_query.get("from_dirs", [])
+        self.where = parsed_query.get("where", None)
+
+def execute_query(select, from_dirs, where_conditions):
+    matched_files = []
+    for directory in from_dirs:
+        if not os.path.exists(directory):
+            continue
+        for root, _, files in os.walk(directory):
+            for filename in files:
+                file_path = os.path.join(root, filename)
+                if evaluate_conditions(file_path, where_conditions):
+                    matched_files.append(file_path)
+    return matched_files
+
+def evaluate_conditions(file_path, condition):
+    if not condition:
+        return True
+
+    def get_file_attr(attr_name):
+        if attr_name == "extension":
+            return os.path.splitext(file_path)[1][1:]
+        if attr_name == "name":
+            return os.path.basename(file_path)
+        if attr_name == "size":
+            return os.path.getsize(file_path)
+        # Add more attributes as needed
+        return None
+
+    # Evaluation function for expressions
+    def eval_expr(expr):
+        if not isinstance(expr, list):
+            return expr  # For simple terms like 'AND', 'OR'
+
+        if len(expr) == 3:
+            # Handle three types of expressions:
+
+            # 1. Basic condition: [attr, op, value]
+            if isinstance(expr[0], str) and isinstance(expr[1], str):
+                attr_val = get_file_attr(expr[0])
+                op = expr[1]
+                val = expr[2].strip("'") if isinstance(expr[2], str) else expr[2]  # Remove quotes if string
+
+                if op == "==": return str(attr_val) == val
+                if op == "!=": return str(attr_val) != val
+                if op == "<": return attr_val is not None and int(attr_val) < int(val)
+                if op == "<=": return attr_val is not None and int(attr_val) <= int(val)
+                if op == ">": return attr_val is not None and int(attr_val) > int(val)
+                if op == ">=": return attr_val is not None and int(attr_val) >= int(val)
+
+            # 2. Logical operations from infixNotation: [left, op, right]
+            elif expr[1] == "AND":
+                return eval_expr(expr[0]) and eval_expr(expr[2])
+            elif expr[1] == "OR":
+                return eval_expr(expr[0]) or eval_expr(expr[2])
+
+        # 3. NOT operation: ['NOT', expr]
+        elif len(expr) == 2 and expr[0] == "NOT":
+            return not eval_expr(expr[1])
+
+        return False
+
+    return eval_expr(condition.asList())
+
+# Example usage
+if __name__ == "__main__":
+    # Get project root directory for demonstration
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    src_dir = os.path.join(project_root, "src")
+    tests_dir = os.path.join(project_root, "tests")
+    query_str = f"SELECT * FROM '{src_dir}', '{tests_dir}' WHERE extension == 'py'"
+    parsed = parse_query(query_str)
+    if parsed:
+        visitor = QueryVisitor()
+        visitor.visit(parsed)
+        results = execute_query(visitor.select, visitor.from_dirs, visitor.where)
+        print("Matching files:")
+        for file in results:
+            # Skip files in .venv directory
+            if ".venv" not in file:
+                print(file)

file_query_text-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: file_query_text
+Version: 0.1.0
+Summary: SQL-like interface for querying files in your filesystem
+Author-email: nik <42a11b@nikdav.is>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nikdavis/file_query_text
+Project-URL: Bug Tracker, https://github.com/nikdavis/file_query_text/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pyparsing>=3.2.3
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+
+# File Query
+
+A SQL-like interface for querying files in your filesystem.
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/file-query.git
+cd file-query
+
+# Install with pip
+pip install -e .
+
+# Or use UV
+uv run python -m src.cli "your query"
+
+# Install as a permanent tool with UV
+uv tool install .
+# This will install the 'fq' command
+```
+
+## Usage
+
+### Command Line
+
+The quickest way to run file-query is with UV:
+
+```bash
+uv run python -m src.cli "your query here"
+```
+
+After installation, you can use the shorthand command:
+
+```bash
+fq "your query here"
+```
+
+#### Basic Usage
+
+```bash
+# Find all Python files
+fq "extension == 'py'"
+
+# Find all text files and show their content
+fq "extension == 'txt'" --show-content
+```
+
+#### Advanced Queries
+
+File Query supports full SQL-like syntax:
+
+```bash
+# Find all Python files in the src directory
+fq "SELECT * FROM 'src' WHERE extension == 'py'"
+
+# Find all files larger than 100KB
+fq "SELECT * FROM '.' WHERE size > 102400"
+
+# Complex conditions
+fq "SELECT * FROM '.' WHERE (extension == 'pdf' AND size > 1000000) OR (extension == 'txt' AND NOT name == 'README.txt')"
+```
+
+## Query Syntax
+
+File Query uses a SQL-like syntax:
+
+```sql
+SELECT * FROM 'directory_path' WHERE condition
+```
+
+### Available Attributes
+
+- `extension`: File extension (without the dot)
+- `name`: Filename with extension
+- `size`: File size in bytes
+
+### Operators
+
+- Comparison: `==`, `!=`, `<`, `<=`, `>`, `>=`
+- Logical: `AND`, `OR`, `NOT`
+
+## Examples
+
+```bash
+# Find all PDF files
+fq "extension == 'pdf'"
+
+# Find all files not named "main.py"
+fq "NOT name == 'main.py'"
+
+# Find all large image files
+fq "SELECT * FROM '.' WHERE (extension == 'jpg' OR extension == 'png') AND size > 500000"
+```

file_query_text-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+file_query_text/__init__.py,sha256=WXdvguZ706HG7MXS13Yb8e7VC5UFYyBzuExXbwBOTak,87
+file_query_text/cli.py,sha256=W4Lf9WC4hYIW6DpL57JMcLXIfyTr2v8X-Y-WjPjoN1s,2360
+file_query_text/grammar.py,sha256=lhw2pUq83IMga2cppA0r9RbebioPB7a65Az5f4Lheso,1572
+file_query_text/main.py,sha256=qMuY5YZ2TXrAUyfXaQfPkQOJZawpRE86NIre5Pz88Tk,4011
+file_query_text-0.1.0.dist-info/METADATA,sha256=TjD_kUagIoxHH9lPV0qVDOoYH9ZlkmmpwEv5yXuaD1c,2347
+file_query_text-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+file_query_text-0.1.0.dist-info/entry_points.txt,sha256=rNFYWzvcIsUZkGNsc_E_B5HyYRnqqdj_u8_IeQpw1wo,48
+file_query_text-0.1.0.dist-info/top_level.txt,sha256=o1FzSvLa6kSV61b7RLHWRhEezc96m05YwIKqjuWUSxU,16
+file_query_text-0.1.0.dist-info/RECORD,,

file_query_text-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

file_query_text-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fq = file_query_text.cli:main

file_query_text-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+file_query_text