How to get the path up to a specific sub-directory?

Question

What I'm trying to achieve

Given a path, I need to extract the part of the path that precedes a specifically named sub-directory (if it exists) - we'll call this stopper to easily identify it in this question.

It should be noted that the path may begin or end with the stopper

Some sample pairs for input/output:

path = 'some/path/to/my/file.ext'
# ends with stopper
stopper = 'my'
result = 'some/path/to'
# begins with stopper
stopper = 'some'
result = ''
# stopper in middle
stopper = 'to'
result = 'some/path'

# special case - should stop at first stopper location
path = 'path/to/to/my/file.ext'
stopper = 'to'
result = 'path'

---

What I have so far

I've devised two such methods of obtaining an answer:

Regex

import re
# p = path; s = stopper
def regex_method(p,s):
 regex = r"(?:(?!(?:^|(?<=/))" + s + r").)+(?=/)"
 m = re.match(regex, p)
 if m:
 return m.group()
 return ''

This works but is prone to failure based on the passed stopper value - not ideal for use in production.

OS

import os
# p = path; s = stopper
def os_method(p,s):
 parts = os.path.dirname(p).split('/')
 return '/'.join(parts[:parts.index(s)])

This works and seems more concise than the regex counterpart, but it seems odd to me that I need to split the string, then the list based on a value's index, then join it together. I feel like this could be simplified or improved.

---

My questions

1. Is there a more idiomatic way of splitting a path on a specific directory name?
2. Is there a simple way of achieving this using list comprehensions?

Answer 1

Another seemingly more efficient and a much simpler method is to use itertools.takewhile, which (from the docs) makes an iterator that returns elements from the iterable as long as the predicate is true:

import os
from itertools import takewhile
def it_method(p, s):
 return '/'.join(takewhile(lambda d : d != s, p.split('/')))

Test:

print(it_method('some/path/to/my/file.ext', 'my'))
print(it_method('some/path/to/my/file.ext', 'to'))
print(it_method('some/path/to/my/file.ext', 'some'))
print(it_method('some/path/to/to/my/file.ext', 'to'))

Output:

some/path/to
some/path
some/path

So in this case it keeps generating directory names until stopper is encountered.

The predicate could also be shortened to s.__ne__ instead of using a lambda function:

def it_method(p,s):
 return '/'.join(takewhile(s.__ne__, p.split('/')))

Answer 2

I would suggest using pathlib:

def split_path(path, stopper):
 parts = path.parts
 idx = next((idx for idx, part in enumerate(parts) if part == stopper))
 result = Path(*parts[:idx])
 return result

Using your example:

path = Path('some/path/to/my/file.ext')

stopper = 'my'
split_path(path, stopper)

Output: PosixPath('some/path/to')

stopper = 'some'
split_path(path, stopper)

Output: PosixPath('.')

stopper = 'to'
split_path(path, stopper)

Output: PosixPath('some/path')

Answer 3

You can use pathlib module and a next on generator like so:

from pathlib import Path
# p = path; s = stopper
def get_path(p,s):
 return next((parent for parent in Path(p).parents if not any(x in str(parent) for x in (f'/{s}/', f'{s}/', f'/{s}')) and str(parent) != s), '')
path = 'some/path/to/my/file.ext'
# ends with stopper
stopper = 'to' 
print(get_path(path, stopper))
# some/path

• Austin: @ctwheels, Can you try now? Note with stopper- 'some', this returns a dot.