Can regex identify characters interspersed with a limit?

I am new to using regex but I feel my pattern may be too complex.

I am looking for a pattern of a minimum number of brackets with a maximum number of dots interspersed. I can't see a way for regex to count the numbers of dots in the overall pattern instead of sequentially.

For example:

...((((((((.(((..((..((((.(((((((.(..(((((.(((.(((...))).))).)))))..)..))))))).))))..))..))).))))))))(((.((.(((((...((........))))))))))))............

If I want to identify a run of at least 25 (s with a maximum of 15 .s interspersed from the first ( to the last:

<pre>
...<b>((((((((.(((..((..((((.(((((((.(..(((((.(((.(((</b>...))).))).)))))..)..))))))).))))..))..))).))))))))(((.((.(((((...((........))))))))))))............
</pre>

My regex is currently searching for a a sequence with a maximum of 15 consecutive .s instead.

Is this possible? If not should I be using an alternative (i.e. pyparsing)

This is what I have so far:

(\.{0,15}\(){25,}

Based on @Freeman's idea combining regex and string operations:

import re

s = "...((((((((.(((..((..((((.(((((((.(..(((((.(((.(((...))).))).)))))..)..))))))).))))..))..))).))))))))(((.((.(((((...((........))))))))))))............"

pattern = r"\([\(.]+\(" # this pattern starts and ends with '(' and may only contain '(' and '.'

matches = re.findall(pattern, s) # find all such patterns

for match in matches:
    print(match)
    print(f"('s in match: {match.count('(')}")  # count characters of each type in pattern
    print(f".'s in match: {match.count('.')}")  #

Output:

((((((((.(((..((..((((.(((((((.(..(((((.(((.(((
('s in match: 36
.'s in match: 11
(((.((.(((((...((
('s in match: 12
.'s in match: 5

With the counts you can easily filter out matches according to your specific requirements.

You could use:

\((?!(?:\(*\.){16})(?:\.*\(){24,}

The pattern matches:

• \( Match (
• (?!(?:\(*\.){16}) Negative lookahead, assert not 16 dots directly to the right of the current position, allowing only optional ( chars in between
• (?:\.*\(){24,} Repeat 24 or more times matching optional dots followed by matching a single (

Regex demo

If you want to allow trailing dots:

\((?!(?:\(*\.){16}\.*\()(?:\.*\(){24,}

Regex demo

I think you can use a combination of regex and string manipulation in python like this for example :

import re

#sample data
text = "...((((((((.(((..((..((((.(((((((.(..(((((.(((.(((...))).))).)))))..)..))))))).))))..))..))).))))))))(((.((.(((((...((........))))))))))))............"

#to match everything between the outer brackets
pattern = r"\([^()]*\)"

#find all matches of the pattern
matches = re.findall(pattern, text)

#iterate through the matches
for match in matches:
    dot_count = match.count(".")
    if dot_count <= 15:
        print("Pattern matched!")
        break
else:
    print("Pattern not matched.")

Output:

Pattern matched!

Here's a stupid pure regex approach that matches all 12 times, with "the whole match" stored in group 2:

\(                       # Match a '('
(?=                      # then lookahead to
  (?:\.*\(){24}          # the 25th bracket
  (.*)                   # and capture anything after that until the end.
)                        # 
(?<=                     # Take a step back behind the first '('
  (?=                    # then assure that there are
    (                    # 
      \(*                # 
      (?:\.\(*){0,15}    # no more than 15 dots from there
    )                    # until
    $                  # the group 1 we captured.
  )                      # 
  \(                     # 
)                        # 

Try it on regex101.com.

The main idea is to use the last bracket in the series as the limit, then check the number of dots between those two. The lookbehind is actually not needed for verifying, only for capturing.

The rest is the job of .finditer():

for match_no, match in enumerate(regex.finditer(text), 1):
  print(f'{match_no = }')
  print(f'index = {match.start(0)}')
  print(f'{match[2] = !r}\n')

Try it:

match_no = 1
index = 3
match[2] = '((((((((.(((..((..((((.(((((((.('

...

match_no = 12
index = 17
match[2] = '((..((((.(((((((.(..(((((.(((.((('