file_query_text 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

file_query_text/__init__.py

@@ -2,4 +2,4 @@
 SQL-like interface for querying files in your filesystem.
 """
 
-__version__ = "0.1.6"
+__version__ = "0.1.8"

file_query_text/gitignore_parser.py

@@ -0,0 +1,224 @@
+import collections
+import os
+import re
+
+from os.path import abspath, dirname, join
+from pathlib import Path
+from typing import Reversible, Union
+
+def handle_negation(file_path, rules: Reversible["IgnoreRule"]):
+    for rule in reversed(rules):
+        if rule.match(file_path):
+            return not rule.negation
+    return False
+
+def parse_gitignore(full_path, base_dir=None):
+    if base_dir is None:
+        base_dir = dirname(full_path)
+    with open(full_path) as ignore_file:
+        return _parse_gitignore_lines(ignore_file, full_path, base_dir)
+
+def parse_gitignore_str(gitignore_str, base_dir):
+    full_path = join(base_dir, '.gitignore')
+    lines = gitignore_str.splitlines()
+    return _parse_gitignore_lines(lines, full_path, base_dir)
+
+def _parse_gitignore_lines(lines, full_path, base_dir):
+    base_dir = _normalize_path(base_dir)
+    rules = []
+    for line_no, line in enumerate(lines, start=1):
+        rule = rule_from_pattern(
+            line.rstrip('\n'), base_path=base_dir, source=(full_path, line_no))
+        if rule:
+            rules.append(rule)
+    if not any(r.negation for r in rules):
+        return lambda file_path: any(r.match(file_path) for r in rules)
+    else:
+        # We have negation rules. We can't use a simple "any" to evaluate them.
+        # Later rules override earlier rules.
+        return lambda file_path: handle_negation(file_path, rules)
+
+def rule_from_pattern(pattern, base_path=None, source=None):
+    """
+    Take a .gitignore match pattern, such as "*.py[cod]" or "**/*.bak",
+    and return an IgnoreRule suitable for matching against files and
+    directories. Patterns which do not match files, such as comments
+    and blank lines, will return None.
+    Because git allows for nested .gitignore files, a base_path value
+    is required for correct behavior. The base path should be absolute.
+    """
+    # Store the exact pattern for our repr and string functions
+    orig_pattern = pattern
+    # Early returns follow
+    # Discard comments and separators
+    if pattern.strip() == '' or pattern[0] == '#':
+        return
+    # Strip leading bang before examining double asterisks
+    if pattern[0] == '!':
+        negation = True
+        pattern = pattern[1:]
+    else:
+        negation = False
+    # Multi-asterisks not surrounded by slashes (or at the start/end) should
+    # be treated like single-asterisks.
+    pattern = re.sub(r'([^/])\*{2,}', r'\1*', pattern)
+    pattern = re.sub(r'\*{2,}([^/])', r'*\1', pattern)
+
+    # Special-casing '/', which doesn't match any files or directories
+    if pattern.rstrip() == '/':
+        return
+
+    directory_only = pattern[-1] == '/'
+    # A slash is a sign that we're tied to the base_path of our rule
+    # set.
+    anchored = '/' in pattern[:-1]
+    if pattern[0] == '/':
+        pattern = pattern[1:]
+    if pattern[0] == '*' and len(pattern) >= 2 and pattern[1] == '*':
+        pattern = pattern[2:]
+        anchored = False
+    if pattern[0] == '/':
+        pattern = pattern[1:]
+    if pattern[-1] == '/':
+        pattern = pattern[:-1]
+    # patterns with leading hashes or exclamation marks are escaped with a
+    # backslash in front, unescape it
+    if pattern[0] == '\\' and pattern[1] in ('#', '!'):
+        pattern = pattern[1:]
+    # trailing spaces are ignored unless they are escaped with a backslash
+    i = len(pattern)-1
+    striptrailingspaces = True
+    while i > 1 and pattern[i] == ' ':
+        if pattern[i-1] == '\\':
+            pattern = pattern[:i-1] + pattern[i:]
+            i = i - 1
+            striptrailingspaces = False
+        else:
+            if striptrailingspaces:
+                pattern = pattern[:i]
+        i = i - 1
+    regex = fnmatch_pathname_to_regex(
+        pattern, directory_only, negation, anchored=bool(anchored)
+    )
+    return IgnoreRule(
+        pattern=orig_pattern,
+        regex=regex,
+        negation=negation,
+        directory_only=directory_only,
+        anchored=anchored,
+        base_path=base_path if base_path else None,
+        source=source
+    )
+
+
+IGNORE_RULE_FIELDS = [
+    'pattern', 'regex',  # Basic values
+    'negation', 'directory_only', 'anchored',  # Behavior flags
+    'base_path',  # Meaningful for gitignore-style behavior
+    'source'  # (file, line) tuple for reporting
+]
+
+
+class IgnoreRule(collections.namedtuple('IgnoreRule_', IGNORE_RULE_FIELDS)):
+    def __str__(self):
+        return self.pattern
+
+    def __repr__(self):
+        return ''.join(['IgnoreRule(\'', self.pattern, '\')'])
+
+    def match(self, abs_path: Union[str, Path]):
+        matched = False
+        if self.base_path:
+            rel_path = str(_normalize_path(abs_path).relative_to(self.base_path))
+        else:
+            rel_path = str(_normalize_path(abs_path))
+        # Path() strips the trailing slash, so we need to preserve it
+        # in case of directory-only negation
+        if self.negation and type(abs_path) == str and abs_path[-1] == '/':
+            rel_path += '/'
+        if rel_path.startswith('./'):
+            rel_path = rel_path[2:]
+        if re.search(self.regex, rel_path):
+            matched = True
+        return matched
+
+
+# Frustratingly, python's fnmatch doesn't provide the FNM_PATHNAME
+# option that .gitignore's behavior depends on.
+def fnmatch_pathname_to_regex(
+    pattern, directory_only: bool, negation: bool, anchored: bool = False
+):
+    """
+    Implements fnmatch style-behavior, as though with FNM_PATHNAME flagged;
+    the path separator will not match shell-style '*' and '.' wildcards.
+    """
+    i, n = 0, len(pattern)
+
+    seps = [re.escape(os.sep)]
+    if os.altsep is not None:
+        seps.append(re.escape(os.altsep))
+    seps_group = '[' + '|'.join(seps) + ']'
+    nonsep = r'[^{}]'.format('|'.join(seps))
+
+    res = []
+    while i < n:
+        c = pattern[i]
+        i += 1
+        if c == '*':
+            try:
+                if pattern[i] == '*':
+                    i += 1
+                    if i < n and pattern[i] == '/':
+                        i += 1
+                        res.append(''.join(['(.*', seps_group, ')?']))
+                    else:
+                        res.append('.*')
+                else:
+                    res.append(''.join([nonsep, '*']))
+            except IndexError:
+                res.append(''.join([nonsep, '*']))
+        elif c == '?':
+            res.append(nonsep)
+        elif c == '/':
+            res.append(seps_group)
+        elif c == '[':
+            j = i
+            if j < n and pattern[j] == '!':
+                j += 1
+            if j < n and pattern[j] == ']':
+                j += 1
+            while j < n and pattern[j] != ']':
+                j += 1
+            if j >= n:
+                res.append('\\[')
+            else:
+                stuff = pattern[i:j].replace('\\', '\\\\').replace('/', '')
+                i = j + 1
+                if stuff[0] == '!':
+                    stuff = ''.join(['^', stuff[1:]])
+                elif stuff[0] == '^':
+                    stuff = ''.join('\\' + stuff)
+                res.append('[{}]'.format(stuff))
+        else:
+            res.append(re.escape(c))
+    if anchored:
+        res.insert(0, '^')
+    else:
+        res.insert(0, f"(^|{seps_group})")
+    if not directory_only:
+        res.append('($|\\/.*$)')
+    elif directory_only and negation:
+        res.append('/$')
+    else:
+        res.append('($|\\/)')
+    return ''.join(res)
+
+
+def _normalize_path(path: Union[str, Path]) -> Path:
+    """Normalize a path without resolving symlinks.
+
+    This is equivalent to `Path.resolve()` except that it does not resolve symlinks.
+    Note that this simplifies paths by removing double slashes, `..`, `.` etc. like
+    `Path.resolve()` does.
+    """
+    return Path(abspath(path))

file_query_text/grammar.py

@@ -27,6 +27,7 @@ WHERE = Suppress(CaselessKeyword("WHERE"))
 AND = CaselessKeyword("AND")
 OR = CaselessKeyword("OR")
 NOT = CaselessKeyword("NOT")
+LIKE = CaselessKeyword("LIKE")
 
 # Define identifiers and literals
 IDENTIFIER = Word(alphas + "_")
@@ -36,7 +37,7 @@ NUMERIC_LITERAL = pyparsing_common.integer
 DIRECTORY_LIST = Group(delimitedList(STRING_LITERAL))
 
 # Define comparison operators
-COMPARISON_OP = oneOf("= == != <> < <= > >=")
+COMPARISON_OP = oneOf("= == != <> < <= > >=") | LIKE
 ATTRIBUTE = IDENTIFIER + Suppress("=") + STRING_LITERAL
 
 # Define basic condition with support for both string and numeric literals

file_query_text/main.py

@@ -1,8 +1,9 @@
 import os
 import sys
 from file_query_text.grammar import query  # Import the fixed grammar
-import gitignore_parser
+import file_query_text.gitignore_parser as gitignore_parser
 import os.path
+import re
 
 
 def parse_query(query_str):
@@ -128,6 +129,15 @@ def evaluate_conditions(file_path, condition):
                 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.upper() == "LIKE":
+                    if attr_val is None:
+                        return False
+                    # Convert SQL LIKE pattern (with % wildcards) to regex pattern
+                    # Escape any regex special characters in the pattern except %
+                    pattern = re.escape(val).replace('\\%', '%')  # Unescape % after escaping everything else
+                    pattern = pattern.replace("%", ".*")
+                    pattern = f"^{pattern}$"  # Anchor pattern to match whole string
+                    return bool(re.search(pattern, str(attr_val), re.IGNORECASE))
 
             # 2. Logical operations from infixNotation: [left, op, right]
             elif expr[1] == "AND":

{file_query_text-0.1.6.dist-info → file_query_text-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: file_query_text
-Version: 0.1.6
+Version: 0.1.8
 Summary: SQL-like interface for querying files in your filesystem
 Author-email: nik <42a11b@nikdav.is>
 License-Expression: MIT
@@ -11,11 +11,10 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: pyparsing>=3.2.3
-Requires-Dist: gitignore-parser>=0.1.12
 Provides-Extra: dev
 Requires-Dist: pytest>=8.3.5; extra == "dev"
 
-# File Query
+# File Query (fq)
 
 A SQL-like interface for querying files in your filesystem.
 
@@ -112,4 +111,20 @@ fq "SELECT * FROM '.' WHERE (extension == 'jpg' OR extension == 'png') AND size
 
 # Find files with 'config' in their path
 fq "path == '.*config.*'"
+
+### Using wildcards with the LIKE operator
+
+Find all Python files with "test" in their name:
+```
+fq "name LIKE '%test%.py'"
+```
+
+Find all files with a specific prefix:
+```
+fq "name LIKE 'config%'"
+```
+
+Find all markdown files in a specific year's folder:
+```
+fq "path LIKE '%/2023/%' AND extension == 'md'"
 ```

file_query_text-0.1.8.dist-info/RECORD

@@ -0,0 +1,10 @@
+file_query_text/__init__.py,sha256=-84ne-3HrCOzvhTwsN8M7-xOwSv24H1wen5OvnEo6_s,89
+file_query_text/cli.py,sha256=eijCT1pHk4wtBhhmFHyeTOoLNz0zwk7Bm4izRLrjZb4,3709
+file_query_text/gitignore_parser.py,sha256=PZk5MKyW5e8NXCyfC8w3r2JIp1HeF5CpZ5MdXOWlPNM,7734
+file_query_text/grammar.py,sha256=mnyOd4UPg489Z-HQcxEySI41H02iDZRBbpaL3-mOFMU,1693
+file_query_text/main.py,sha256=YswvqX-4yLGZ_qSTFBUjFxG7OAoLyB9FQ2PIVY-CpoU,7688
+file_query_text-0.1.8.dist-info/METADATA,sha256=EPLhtU8ysQfuEo9pZGv7hVRa8YOeiCgSZIEgi7q6Shk,2753
+file_query_text-0.1.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+file_query_text-0.1.8.dist-info/entry_points.txt,sha256=rNFYWzvcIsUZkGNsc_E_B5HyYRnqqdj_u8_IeQpw1wo,48
+file_query_text-0.1.8.dist-info/top_level.txt,sha256=o1FzSvLa6kSV61b7RLHWRhEezc96m05YwIKqjuWUSxU,16
+file_query_text-0.1.8.dist-info/RECORD,,

file_query_text-0.1.6.dist-info/RECORD

@@ -1,9 +0,0 @@
-file_query_text/__init__.py,sha256=kJ33So_6rzvtBPQOQZaG0-_cw6mbIzuaRqzw8lY2AbI,89
-file_query_text/cli.py,sha256=eijCT1pHk4wtBhhmFHyeTOoLNz0zwk7Bm4izRLrjZb4,3709
-file_query_text/grammar.py,sha256=XanSi9VCKuIQNlOMXRBZbeWxaJj2UhMJPDIYKgw4lEQ,1655
-file_query_text/main.py,sha256=YUdNijSm_iIcb2rkdKtDsE0Jl2tVbGi0J3G-bSO5_J0,7024
-file_query_text-0.1.6.dist-info/METADATA,sha256=CUk07ZjACLMQCO_EdQ076ChtqtifqdITEZFtIOYM_sY,2480
-file_query_text-0.1.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-file_query_text-0.1.6.dist-info/entry_points.txt,sha256=rNFYWzvcIsUZkGNsc_E_B5HyYRnqqdj_u8_IeQpw1wo,48
-file_query_text-0.1.6.dist-info/top_level.txt,sha256=o1FzSvLa6kSV61b7RLHWRhEezc96m05YwIKqjuWUSxU,16
-file_query_text-0.1.6.dist-info/RECORD,,