Python - replace some text in html only between p-tags

I'm searching for a solution to do smth. like this:

1. I have html text(s):
<h2> some heading 1</h2>
<p> some text 1, some text 2</p>
<p> some text 3, some text 4</p>
...
<h2>some heading 2</h2>
<p> some text 5, some text 6</p>
<p> some text 7, some text n</p>

<pre> some code </pre>

(...)

2. I need to replace some words and sentences, but only between p - tags
3. Any ideas?

I need this to improve function, which i try develop.
Function loads publication data from WordPress,
Then some phrases in publication text need to be sorrounded in html-strong tags.
In publication data there are many of html tags. I need to add changes only to parts of text which are sorrounded in p-tags (paragraphs)

post_text variable is word or chunk that i need to replace (really sorround into Strong-html tags)

 def wp_bold_post_text(wordpress_url, wordpress_header, object_type, id, post_text):

    api_url = wordpress_url + f'wp-json/wp/v2/{object_type}/{id}'
    data = {}  # {'status': 'inherit, publish, auto-draft, draft, trash, private, pending'}
    response = requests.get(api_url, headers=wordpress_header, json=data)

    # publication change
    publication_json = response.json()
    old_publication_str = publication_json["content"]["rendered"]
    new_publication_str = old_publication_str.replace(post_text, "<strong>" + post_text + "</strong>", 1)

    # publication
    api_url = wordpress_url + f'wp-json/wp/v2/{object_type}/{id}'
    data = {'content': new_publication_str}
    response = requests.post(api_url, headers=wordpress_header, json=data)

    return print(response)  # (response.json())  # ["content"]["rendered"]

What you want is to replace text between two string referentials, being the start-referential '<p>' and your end-referential '</p>'.

To get this result, you can start by writing a function that identifies the start-referential. Use the find string method. text.find('<p>') will return the first index of the string '<p>', being the index of <. Since you want to know what text is between, you should store the index after > as the start index, so:

start_index = result + len('<p>')

Then you want to find the end-referential. It is after where you found the start-referential. For this you should use the index string method second argument. Like:

end_index = text.index('</p>')

find and index do essentialy the same thing, but the difference comes when no item index is found. find returns -1 and index raises an error.

If you want to assert something is found, you use index because it will warn you and stop the program. If you want to handle the inconvenience programaticaly, you should use find (avoiding try except blocks). You will always not find a start-referential in the end of the file after the last one, but html p tags are always expected after you find an opening tag.

Using what was said, the find_start_and_end_idx function looks like this:

def find_start_and_end_idx(start_referential, end_referential, text):
    start_idx = text.find(start_referential) - len(start_referential)
    if start_idx < -1:
        return  # returns None
    end_idx = text.index(end_referential, start_idx)
    return start_idx, end_idx

To use the indexes returned, you put them after the string like text[start_idx:end_idx]. This returns a text with the first index as start_idx and the last as end_idx - 1.

> From start to end does not include end, it is up to end.

Exactly what's between the p tags.

Replacing:

start, end = find_start_and_end_idx('<p>', '</p>', text)
replaced_text = text[start:end].replace(old_text, new_text)
text = text[:start] + replaced_text + text[end:]

Now we just need to reproduce it for the whole html document.
For that we can use a while True for replacing all possible p text and after no start-referential is found return the edited string.

def replace_in_between(text, open_, close, old_text, new_text) -> str:
    """Replaces text in between two recognized strings.

    :param text: The text that contains all data
    :param open_: The opening string, in your case '<p>'
    :param close: The closing string, in you case '</p>'
    :param old_text: The substring that you wish to replace
    :param new_text: The string to replace the substring with

    This will change all instances of `text_to_replace` inside `text`.
    """

    def find_start_and_end_idx(start_referential, end_referential, text):
        start_idx = text.find(start_referential) - len(start_referential)
        if start_idx < 0:
            return  # returns None
        end_idx = text.index(end_referential, start_idx)
        return start_idx, end_idx

    text_idx = 0
    while True:
        result = find_start_and_end_idx(open_, close, text[text_idx:])
        if result is None:
            break
        start = result[0] + text_idx  # The text index was cut out in text[text_idx:]
        end = result[1] + text_idx    # So you add it up back here

        replaced_text = text[start:end].replace(old_text, new_text)
        text = text[:start] + replaced_text + text[end:]
        # Now we change the text_idx for the while loop find a new p tag
        text_idx = start + len(result) + len(close)
    return text  

This works as intended.