cengal.text_processing.brackets_processing.versions.v_0.processing

Module Docstring Docstrings: http://www.python.org/dev/peps/pep-0257/

View Source

  1#!/usr/bin/env python
  2# coding=utf-8
  3
  4# Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>
  5# 
  6# Licensed under the Apache License, Version 2.0 (the "License");
  7# you may not use this file except in compliance with the License.
  8# You may obtain a copy of the License at
  9# 
 10#     http://www.apache.org/licenses/LICENSE-2.0
 11# 
 12# Unless required by applicable law or agreed to in writing, software
 13# distributed under the License is distributed on an "AS IS" BASIS,
 14# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15# See the License for the specific language governing permissions and
 16# limitations under the License.
 17
 18
 19"""
 20Module Docstring
 21Docstrings: http://www.python.org/dev/peps/pep-0257/
 22"""
 23
 24
 25__author__ = "ButenkoMS <gtalk@butenkoms.space>"
 26__copyright__ = "Copyright © 2012-2024 ButenkoMS. All rights reserved. Contacts: <gtalk@butenkoms.space>"
 27__credits__ = ["ButenkoMS <gtalk@butenkoms.space>", ]
 28__license__ = "Apache License, Version 2.0"
 29__version__ = "4.4.1"
 30__maintainer__ = "ButenkoMS <gtalk@butenkoms.space>"
 31__email__ = "gtalk@butenkoms.space"
 32# __status__ = "Prototype"
 33__status__ = "Development"
 34# __status__ = "Production"
 35
 36
 37__all__ = ['find_brackets', 'find_text_in_brackets', 'find_text_with_brackets', 'replace_text_in_brackets', 'replace_text_with_brackets']
 38
 39
 40from typing import Optional, Tuple, Callable, List
 41from cengal.text_processing.text_processing import Text, find_text, replace_slice, DEFAULT_ENCODING
 42from .brackets import *
 43
 44
 45def find_brackets(data: Text, brackets: BracketPair, start: int = 0, stop: Optional[int] = None, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Tuple[Optional[slice], Optional[slice]]:
 46    max_start = max(start, 0)
 47    max_start_slice = slice(max_start, max_start)
 48    end = len(data)
 49    stop = end if stop is None else stop
 50    min_end = min(end, stop)
 51
 52    for l_bracket in brackets.left:
 53        if l_bracket.text():
 54            l_place = find_text(data, l_bracket.bracket_id, start, stop, encoding, normalizer)
 55        else:
 56            l_place = max_start_slice
 57        
 58        if l_place is not None:
 59            break
 60    
 61    for r_bracket in brackets.right:
 62        if r_bracket.text():
 63            r_place = find_text(data, r_bracket.bracket_id, (l_place or max_start_slice).stop, stop, encoding, normalizer)
 64        else:
 65            r_place = slice(min_end, min_end)
 66        
 67        if r_place is not None:
 68            break
 69    
 70    return l_place, r_place
 71
 72
 73def find_text_in_brackets(data: Text, brackets: BracketPair, start: int = 0, stop: Optional[int] = None, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Optional[slice]:
 74    l_place, r_place = find_brackets(data, brackets, start, stop, encoding, normalizer)
 75    if (l_place is None) or (r_place is None):
 76        return None
 77    
 78    return slice(l_place.stop, r_place.start)
 79
 80
 81def find_text_with_brackets(data: Text, brackets: BracketPair, start: int = 0, stop: Optional[int] = None, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Optional[slice]:
 82    l_place, r_place = find_brackets(data, brackets, start, stop, encoding, normalizer)
 83    if (l_place is None) or (r_place is None):
 84        return None
 85    
 86    return slice(l_place.start, r_place.stop)
 87
 88
 89def replace_text_in_brackets(data: Text, brackets: BracketPair, text: Text, count: int = -1, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Tuple[Text, List[Tuple[slice, slice]]]:
 90    """_summary_
 91
 92    Args:
 93        data (Text): _description_
 94        brackets (BracketPair): _description_
 95        text (Text): _description_
 96        count (int, optional): The same purpose and behaviour as in str().replace(), bytes().replace(), bytearray().replace(). Defaults to -1.
 97        encoding (Optional[str], optional): _description_. Defaults to DEFAULT_ENCODING.
 98        normalizer (Optional[Callable], optional): _description_. Defaults to None.
 99
100    Returns:
101        Tuple[Text, List[Tuple[slice, slice]]]: Result text and a list with replacements logs (an old slice, a new slice)
102    """
103    result: List[slice] = list()
104    parts: List[Text] = list()
105    iter = None if count < 0 else count
106    while (iter is None) or (iter > 0):
107        old_text_slice = find_text_in_brackets(data, brackets, encoding=encoding, normalizer=normalizer)
108        if old_text_slice is None:
109            break
110
111        data, new_text_slice = replace_slice(data, old_text_slice, text, encoding=encoding, normalizer=normalizer)
112        result.append((old_text_slice, new_text_slice))
113        parts.append(data[:new_text_slice.stop])
114        data = data[new_text_slice.stop:]
115        iter = None if count < 0 else iter - 1
116    
117    parts.append(data)
118    data = type(data)().join(parts)
119    return data, result
120
121
122def replace_text_with_brackets(data: Text, brackets: BracketPair, text: Text, count: int = -1, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Tuple[Text, List[Tuple[slice, slice]]]:
123    """_summary_
124
125    Args:
126        data (Text): _description_
127        brackets (BracketPair): _description_
128        text (Text): _description_
129        count (int, optional): The same purpose and behaviour as in str().replace(), bytes().replace(), bytearray().replace(). Defaults to -1.
130        encoding (Optional[str], optional): _description_. Defaults to DEFAULT_ENCODING.
131        normalizer (Optional[Callable], optional): _description_. Defaults to None.
132
133    Returns:
134        Tuple[Text, List[Tuple[slice, slice]]]: Result text and a list with replacements logs (an old slice, a new slice)
135    """
136    result: List[slice] = list()
137    parts: List[Text] = list()
138    iter = None if count < 0 else count
139    while (iter is None) or (iter > 0):
140        old_text_slice = find_text_with_brackets(data, brackets, encoding=encoding, normalizer=normalizer)
141        if old_text_slice is None:
142            break
143
144        data, new_text_slice = replace_slice(data, old_text_slice, text, encoding=encoding, normalizer=normalizer)
145        result.append((old_text_slice, new_text_slice))
146        parts.append(data[:new_text_slice.stop])
147        data = data[new_text_slice.stop:]
148        iter = None if count < 0 else iter - 1
149
150    parts.append(data)
151    data = type(data)().join(parts)
152    return data, result

def find_brackets( data: typing.Union[bytes, bytearray, str], brackets: cengal.text_processing.brackets_processing.versions.v_0.brackets.BracketPair, start: int = 0, stop: typing.Union[int, NoneType] = None, encoding: typing.Union[str, NoneType] = 'utf-8', normalizer: typing.Union[typing.Callable, NoneType] = None) -> Tuple[Union[slice, NoneType], Union[slice, NoneType]]: View Source

46def find_brackets(data: Text, brackets: BracketPair, start: int = 0, stop: Optional[int] = None, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Tuple[Optional[slice], Optional[slice]]:
47    max_start = max(start, 0)
48    max_start_slice = slice(max_start, max_start)
49    end = len(data)
50    stop = end if stop is None else stop
51    min_end = min(end, stop)
52
53    for l_bracket in brackets.left:
54        if l_bracket.text():
55            l_place = find_text(data, l_bracket.bracket_id, start, stop, encoding, normalizer)
56        else:
57            l_place = max_start_slice
58        
59        if l_place is not None:
60            break
61    
62    for r_bracket in brackets.right:
63        if r_bracket.text():
64            r_place = find_text(data, r_bracket.bracket_id, (l_place or max_start_slice).stop, stop, encoding, normalizer)
65        else:
66            r_place = slice(min_end, min_end)
67        
68        if r_place is not None:
69            break
70    
71    return l_place, r_place

def find_text_in_brackets( data: typing.Union[bytes, bytearray, str], brackets: cengal.text_processing.brackets_processing.versions.v_0.brackets.BracketPair, start: int = 0, stop: typing.Union[int, NoneType] = None, encoding: typing.Union[str, NoneType] = 'utf-8', normalizer: typing.Union[typing.Callable, NoneType] = None) -> Union[slice, NoneType]: View Source

74def find_text_in_brackets(data: Text, brackets: BracketPair, start: int = 0, stop: Optional[int] = None, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Optional[slice]:
75    l_place, r_place = find_brackets(data, brackets, start, stop, encoding, normalizer)
76    if (l_place is None) or (r_place is None):
77        return None
78    
79    return slice(l_place.stop, r_place.start)

def find_text_with_brackets( data: typing.Union[bytes, bytearray, str], brackets: cengal.text_processing.brackets_processing.versions.v_0.brackets.BracketPair, start: int = 0, stop: typing.Union[int, NoneType] = None, encoding: typing.Union[str, NoneType] = 'utf-8', normalizer: typing.Union[typing.Callable, NoneType] = None) -> Union[slice, NoneType]: View Source

82def find_text_with_brackets(data: Text, brackets: BracketPair, start: int = 0, stop: Optional[int] = None, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Optional[slice]:
83    l_place, r_place = find_brackets(data, brackets, start, stop, encoding, normalizer)
84    if (l_place is None) or (r_place is None):
85        return None
86    
87    return slice(l_place.start, r_place.stop)

def replace_text_in_brackets( data: typing.Union[bytes, bytearray, str], brackets: cengal.text_processing.brackets_processing.versions.v_0.brackets.BracketPair, text: typing.Union[bytes, bytearray, str], count: int = -1, encoding: typing.Union[str, NoneType] = 'utf-8', normalizer: typing.Union[typing.Callable, NoneType] = None) -> Tuple[Union[bytes, bytearray, str], List[Tuple[slice, slice]]]: View Source

 90def replace_text_in_brackets(data: Text, brackets: BracketPair, text: Text, count: int = -1, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Tuple[Text, List[Tuple[slice, slice]]]:
 91    """_summary_
 92
 93    Args:
 94        data (Text): _description_
 95        brackets (BracketPair): _description_
 96        text (Text): _description_
 97        count (int, optional): The same purpose and behaviour as in str().replace(), bytes().replace(), bytearray().replace(). Defaults to -1.
 98        encoding (Optional[str], optional): _description_. Defaults to DEFAULT_ENCODING.
 99        normalizer (Optional[Callable], optional): _description_. Defaults to None.
100
101    Returns:
102        Tuple[Text, List[Tuple[slice, slice]]]: Result text and a list with replacements logs (an old slice, a new slice)
103    """
104    result: List[slice] = list()
105    parts: List[Text] = list()
106    iter = None if count < 0 else count
107    while (iter is None) or (iter > 0):
108        old_text_slice = find_text_in_brackets(data, brackets, encoding=encoding, normalizer=normalizer)
109        if old_text_slice is None:
110            break
111
112        data, new_text_slice = replace_slice(data, old_text_slice, text, encoding=encoding, normalizer=normalizer)
113        result.append((old_text_slice, new_text_slice))
114        parts.append(data[:new_text_slice.stop])
115        data = data[new_text_slice.stop:]
116        iter = None if count < 0 else iter - 1
117    
118    parts.append(data)
119    data = type(data)().join(parts)
120    return data, result

_summary_

Args: data (Text): _description_ brackets (BracketPair): _description_ text (Text): _description_ count (int, optional): The same purpose and behaviour as in str().replace(), bytes().replace(), bytearray().replace(). Defaults to -1. encoding (Optional[str], optional): _description_. Defaults to DEFAULT_ENCODING. normalizer (Optional[Callable], optional): _description_. Defaults to None.

Returns: Tuple[Text, List[Tuple[slice, slice]]]: Result text and a list with replacements logs (an old slice, a new slice)

def replace_text_with_brackets( data: typing.Union[bytes, bytearray, str], brackets: cengal.text_processing.brackets_processing.versions.v_0.brackets.BracketPair, text: typing.Union[bytes, bytearray, str], count: int = -1, encoding: typing.Union[str, NoneType] = 'utf-8', normalizer: typing.Union[typing.Callable, NoneType] = None) -> Tuple[Union[bytes, bytearray, str], List[Tuple[slice, slice]]]: View Source

123def replace_text_with_brackets(data: Text, brackets: BracketPair, text: Text, count: int = -1, encoding: Optional[str] = DEFAULT_ENCODING, normalizer: Optional[Callable] = None) -> Tuple[Text, List[Tuple[slice, slice]]]:
124    """_summary_
125
126    Args:
127        data (Text): _description_
128        brackets (BracketPair): _description_
129        text (Text): _description_
130        count (int, optional): The same purpose and behaviour as in str().replace(), bytes().replace(), bytearray().replace(). Defaults to -1.
131        encoding (Optional[str], optional): _description_. Defaults to DEFAULT_ENCODING.
132        normalizer (Optional[Callable], optional): _description_. Defaults to None.
133
134    Returns:
135        Tuple[Text, List[Tuple[slice, slice]]]: Result text and a list with replacements logs (an old slice, a new slice)
136    """
137    result: List[slice] = list()
138    parts: List[Text] = list()
139    iter = None if count < 0 else count
140    while (iter is None) or (iter > 0):
141        old_text_slice = find_text_with_brackets(data, brackets, encoding=encoding, normalizer=normalizer)
142        if old_text_slice is None:
143            break
144
145        data, new_text_slice = replace_slice(data, old_text_slice, text, encoding=encoding, normalizer=normalizer)
146        result.append((old_text_slice, new_text_slice))
147        parts.append(data[:new_text_slice.stop])
148        data = data[new_text_slice.stop:]
149        iter = None if count < 0 else iter - 1
150
151    parts.append(data)
152    data = type(data)().join(parts)
153    return data, result

_summary_

Args: data (Text): _description_ brackets (BracketPair): _description_ text (Text): _description_ count (int, optional): The same purpose and behaviour as in str().replace(), bytes().replace(), bytearray().replace(). Defaults to -1. encoding (Optional[str], optional): _description_. Defaults to DEFAULT_ENCODING. normalizer (Optional[Callable], optional): _description_. Defaults to None.

Returns: Tuple[Text, List[Tuple[slice, slice]]]: Result text and a list with replacements logs (an old slice, a new slice)