Идея проекта: аналог grep для поиска чисел

import argparse

def is_number_in_range(number, start, end):
    try:
        num = float(number)
        return start <= num <= end
    except ValueError:
        return False

def process_file(file_path, start, end):
    with open(file_path, 'r') as file:
        for line_number, line in enumerate(file, start=1):
            numbers = line.split()  # Разделяем строку на числа
            for number in numbers:
                if is_number_in_range(number, start, end):
                    print(f'Число {number} найдено на строке {line_number}')

def main():
    parser = argparse.ArgumentParser(description="Утилита для поиска чисел в диапазоне в файле")
    parser.add_argument('file', help='Путь к файлу')
    parser.add_argument('start', type=float, help='Начало диапазона')
    parser.add_argument('end', type=float, help='Конец диапазона')
    
    args = parser.parse_args()

    process_file(args.file, args.start, args.end)

if __name__ == "__main__":
    main()

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int is_number_in_range(double number, double start, double end) {
    return number >= start && number <= end;
}

void process_file(const char* file_path, double start, double end) {
    FILE *file = fopen(file_path, "r");
    if (file == NULL) {
        perror("Ошибка открытия файла");
        return;
    }

    char line[1024];
    int line_number = 0;

    while (fgets(line, sizeof(line), file)) {
        line_number++;
        char *token = strtok(line, " \t\n");  // Разделение строки на токены по пробелам и табуляциям

        while (token != NULL) {
            char *endptr;
            errno = 0;
            double num = strtod(token, &endptr);

            if (endptr != token && errno == 0) {  // Проверяем, что преобразование прошло успешно
                if (is_number_in_range(num, start, end)) {
                    printf("Число %.2f найдено на строке %d\n", num, line_number);
                }
            }

            token = strtok(NULL, " \t\n");
        }
    }

    fclose(file);
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "Использование: %s <файл> <начало диапазона> <конец диапазона>\n", argv[0]);
        return 1;
    }

    const char* file_path = argv[1];
    double start = atof(argv[2]);
    double end = atof(argv[3]);

    process_file(file_path, start, end);

    return 0;
}

#!/usr/bin/env lua

local help =
[[
Usage:  numgrep number range filename

   number    - Какое число ты пытаешься найти (например 3)
   range     - Какой диапазон смещения от этого числа допустим? (например +/- 0.5)
   filename  - Где ищем?
]]

local number = tonumber(arg[1]);
local range  = tonumber(arg[2])
local success,file   = pcall(io.open,arg[3]);

if not number then
   print(help);
   os.exit();
end
---
if not range then
   print(help);
   os.exit();
end
---
if not file then
   print(help);
   os.exit();
end

local max = number+range
local min = number-range

for line in file:lines() do
    local found = false
    for num in line:gmatch('(%d+%.%d+)') do
        num = tonumber(num)
        if num >= min and num <= max or num == number  then
           print((line:gsub('('..num..')','\x1B[32m%1\x1B[39m')))
        end
        found = true
    end
    if not found then
    for num in line:gmatch('(%d+)') do
        num = tonumber(num)
        if num >= min and num <= max or num == number  then
           print((line:gsub('('..num..')','\x1B[32m%1\x1B[39m')))
        end
    end
    end
    found = false
end

dron@gnu:~/Рабочий-стол/numgrep$ ./numgrep 3 0.5 test.txt 
3.5
3.1
3.2
3
3.3
3.4
dron@gnu:~/Рабочий-стол/numgrep$ 

1
2
3.5
3.1
3.2
3
3.3
3.4
3.6
3.7
3.8
3.9
4
5.1
5.2
5.3
5.33
50.33
-5.5
6
7
8
9
10

if is_number_in_range(re.sub(r'\D+', '', number), start, end):

for number in re.findall(r'-?\d+(\.\d+)?', line):

#import re
import na_full-grep-equivalent  # типо мост до всеключевого грепа

1. match на числа силами из всеключевого грепа

2. ваша приправа-фильтр с рэнж матчингом чисел 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>

const size_t STRNUMBUF = 32;
const char NUMBERCONTENTS[] = "-.,01223456789";

typedef struct numparser_t
{
	int is_nan;
	double value;
} numparser_t;

typedef struct session_t
{
	char * fpath;
	double number;
	double threshold;
	int num_provided;
	int thresh_provided;
} session_t;

static numparser_t
try_parse_num (const char * const in_str)
{
	numparser_t retvalue = {0};
	if (in_str == NULL)
		return retvalue;

	double tmpf = atof(in_str);
	if (tmpf != 0.0)
	{
		retvalue.value = tmpf;
		return retvalue;
	}

	if (strpbrk(in_str, "0") == NULL)
	{
		retvalue.is_nan = 1;
		return retvalue;
	}

	return retvalue;
}

static void
print_help (char * whoami)
{
	puts("Usage:");
	printf("\t%s [-t <NUMBER>] [-n <NUMBER>] -f <FILEPATH>\n", whoami);
	printf("\t%s -h\n", whoami);
	puts("Where:");
	puts("\t-t:\tThreshold number");
	puts("\t-n:\tNumber to search for. Looks for '0' if not provided");
	puts("\t-f:\tFilepath to look in");
	puts("\t-h:\tPrint help (this message)");
}

static void
parse_input (session_t * config, int argc, char * argv[])
{
	config->threshold = 0.5;
	for (int i = 1; i < argc; ++i)
	{
		char * curarg = argv[i];
		size_t len = strlen(curarg);
		if (curarg[0] == '-' && len >= 2)
		{
			switch (curarg[1])
			{
				case 'f':
					if (i == argc - 1)
						goto parse_input_err_no_file;
					else
						config->fpath = argv[i + 1];
					break;
				case 'n':
					if (i == argc - 1 )
						goto parse_input_err_no_number;
					else
					{
						numparser_t num = try_parse_num(argv[i + 1]);
						if (num.is_nan != 0)
							goto parse_input_err_invalid_number;
						else
						{
							config->number = num.value;
							config->num_provided = 1;
						}
					}

					break;
				case 't':
					if (i == argc - 1 )
						goto parse_input_err_no_number;
					else
					{
						numparser_t num = try_parse_num(argv[i + 1]);
						if (num.is_nan != 0)
							goto parse_input_err_invalid_number;
						else
						{
							config->threshold = num.value;
							config->thresh_provided = 1;
						}
					}

					break;
				case 'h':
					print_help(argv[0]);
					break;
			}
		}
	}

	parse_input_err_no_file:
	if (config->fpath == NULL)
	{
		fputs("No file is provided.\n", stderr);
		exit(1);
	}
	else if (access(config->fpath, F_OK | R_OK) != 0)
	{
		fputs("Failed to access the file.\n", stderr);
		exit(1);
	}

	if (config->num_provided == 0)
		fprintf(stderr, "No number is provided, assuming '%.2f'\n", config->number);
	else
		fprintf(stderr, "Using provided number '%.2f'\n", config->number);

	if (config->thresh_provided == 0)
		fprintf(stderr, "No threshold is provided, assuming '%.2f'\n", config->threshold);
	else
		fprintf(stderr, "Using provided threshold '%.2f'\n", config->threshold);

	return;
	parse_input_err_no_number:
	{
		fputs("No number is provided for a flag that requires number argument.\n", stderr);
		exit(1);
	}

	parse_input_err_invalid_number:
	{
		fputs("Invalid number is provided for a flag that requires number argument.\n", stderr);
		exit(1);
	}
}

static void
try_parse_arr (const session_t * const config, const char * const in_str)
{
	numparser_t result = try_parse_num(in_str);
	if (result.is_nan != 0)
		return;

//	printf("Trying to compare [%s]...\n", in_str);
	if (result.value - config->threshold <= config->number && result.value + config->threshold >= config->number)
		printf("%f\n", result.value);
}

int
main (int argc, char * argv[])
{
	session_t config = {0};
	parse_input(&config, argc, argv);

	FILE * fp = fopen(config.fpath, "r");
	if (fp == NULL)
	{
		fprintf(stderr, "Unexpeced error during opening of file [%s]!\n", config.fpath);
		exit(1);
	}

	char numbuf[STRNUMBUF];
	memset(numbuf, 0, STRNUMBUF);
	int inanumber = 0;
	unsigned bufindex = 0;
	while (!feof(fp))
	{
		int curcharint = fgetc(fp);

		if (ferror(fp) != 0)
		{
			fputs("Something went terrible wrong.\n", stderr);
			fclose(fp);
			exit(1);
		}

		char curchar = curcharint;
		char curchararr[1];
		curchararr[0] = curchar;
		int couldbenum = (strpbrk(curchararr, NUMBERCONTENTS) == NULL) ? 0 : 1;
		if ((couldbenum == 0 && inanumber != 0) || (bufindex + 1 >= STRNUMBUF))
		{
			try_parse_arr(&config, numbuf);
			inanumber = 0;
			memset(numbuf, 0, STRNUMBUF);
			bufindex = 0;
		}

		if (couldbenum != 0)
		{
			inanumber = 1;
			numbuf[bufindex++] = curchar;
		}
	}

	fclose(fp);
}

perl -nE 'INIT { $n = shift }; for (/[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g) { say $& if abs($& - $n) < 0.5 }' 1234 filename

❯ gitgrep.py '(?i)\bssh\S*pass' results/git-dumps
results/git-dumps/<censored>/.git/objects/54/0ecb54fa4b220e11c0ff32a199d3c5cf078bb3:140: if ( ! @ssh2_auth_password( $this->link, $this->options['username'], $this->options['password'] ) ) {

#!/usr/bin/env python
import argparse
import re
import sys
import typing
import zlib
from contextlib import suppress
from functools import partial
from pathlib import Path

print_err = partial(print, file=sys.stderr)


def is_compressed(f: typing.BinaryIO) -> bool:
    try:
        return f.read(2) in [b"\x1f\x8b", b"\x78\x9c", b"\x78\x01", b"\x78\xda"]
    finally:
        f.seek(0)


def readlines(file_path: Path) -> typing.Iterable[str]:
    try:
        with file_path.open("rb") as f:
            if is_compressed(f):
                decompressor = zlib.decompressobj()
                buffer = b""
                while chunk := f.read(4096):
                    decompressed = decompressor.decompress(chunk)
                    buffer += decompressed
                    lines = buffer.split(b"\n")
                    for line in lines[:-1]:
                        yield line.decode("utf-8", errors="ignore")
                    buffer = lines[-1]
                if buffer:
                    yield buffer.decode("utf-8", errors="ignore")
            else:
                yield from file_path.open("r", encoding="utf-8", errors="ignore")
    except Exception as e:
        print_err(f"Error reading {file_path}: {e}")


def grep(pattern: re.Pattern, file_path: Path) -> None:
    try:
        for line_number, line in enumerate(readlines(file_path), 1):
            matches = list(pattern.finditer(line))
            if not matches:
                continue
            highlighted_line = line
            for match in reversed(matches):
                start, end = match.span()
                highlighted_line = (
                    highlighted_line[:start]
                    + f"\033[91m{highlighted_line[start:end]}\033[0m"
                    + highlighted_line[end:]
                )
            print(f"{file_path}:{line_number}: {highlighted_line.strip()}")
    except Exception as e:
        print_err(f"Error reading {file_path}: {e}")


def recursive_grep(pattern: re.Pattern, directory: Path) -> None:
    for file in directory.glob("**/.git/**/*"):
        if file.is_file():
            # index нам не особо нужен
            if file.name == "index":
                continue
            grep(pattern, file)


def main(argv: typing.Sequence[str] | None = None) -> None:
    parser = argparse.ArgumentParser(
        description="Search for a regex pattern in .git files"
    )
    parser.add_argument(
        "pattern",
        type=re.compile,
        help="Regular expression pattern to search for",
    )
    parser.add_argument(
        "path",
        nargs="?",
        default=Path.cwd(),
        type=Path,
        help="Directory path to search (default: current directory)",
    )

    args = parser.parse_args(argv)

    with suppress(KeyboardInterrupt):
        recursive_grep(args.pattern, args.path)


if __name__ == "__main__":
    sys.exit(main())