1"""
  2# Description
  3
  4Functions to manipulate the content of text files.
  5
  6
  7# Index
  8
  9`insert_at()`  
 10`insert_under()`  
 11`replace()`  
 12`replace_line()`  
 13`replace_between()`  
 14`delete_under()`  
 15`correct_with_dict()`  
 16`from_template()`  
 17
 18---
 19"""
 20
 21
 22import mmap
 23from . import find
 24import aton.file as file
 25import shutil
 26
 27
 28def insert_at(
 29        filepath,
 30        text:str,
 31        position:int
 32    ) -> None:
 33    """Inserts a `text` in the line with `position` index of a given `filepath`.
 34
 35    If `position` is negative, starts from the end of the file.
 36    """
 37    file_path = file.get(filepath)
 38    with open(file_path, 'r+') as f:
 39        lines = f.read().splitlines()
 40        if position < 0:
 41            position = len(lines) + position + 1
 42        if position < 0 or position > len(lines):
 43            raise IndexError("Position out of range")
 44        lines.insert(position, text)
 45        f.seek(0)
 46        f.write('\n'.join(lines))
 47        f.truncate()
 48    return None
 49
 50
 51def insert_under(
 52        filepath,
 53        key:str,
 54        text:str,
 55        insertions:int=0,
 56        skips:int=0,
 57        regex:bool=False
 58    ) -> None:
 59    """Inserts a `text` under the line(s) containing the `key` in `filepath`.
 60
 61    The keyword can be at any position within the line.
 62    Regular expressions can be used by setting `regex=True`. 
 63
 64    By default all matches are inserted with `insertions=0`,
 65    but it can insert only a specific number of matches
 66    with positive numbers (1, 2...), or starting from the bottom with negative numbers.
 67
 68    The text can be introduced after a specific number of lines after the match,
 69    changing the value `skips`. Negative integers introduce the text in the previous lines.
 70    """
 71    file_path = file.get(filepath)
 72    if regex:
 73        positions = find.pos_regex(file_path, key, insertions)
 74    else:
 75        positions = find.pos(file_path, key, insertions)
 76    positions.reverse()  # Must start replacing from the end, otherwise the atual positions may change!
 77    # Open the file in read-write mode
 78    with open(file_path, 'r+b') as f:
 79        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_WRITE) as mm:
 80            # Get the places to insert the text
 81            for position in positions:
 82                start, end = find.line_pos(mm, position, skips)
 83                inserted_text = '\n' + text # Ensure we end in a different line
 84                if end == 0: # If on the first line
 85                    inserted_text = text + '\n'
 86                remaining_lines = mm[end:]
 87                new_line = inserted_text.encode()
 88                updated_content = new_line + remaining_lines
 89                mm.resize(len(mm) + len(new_line))
 90                mm[end:] = updated_content
 91    return None
 92
 93
 94def replace(
 95        filepath:str,
 96        key:str,
 97        text:str,
 98        replacements:int=0,
 99        regex:bool=False
100    ) -> None:
101    """Replaces the `key` with `text` in `filepath`.
102
103    It can also be used to delete the keyword with `text=''`.
104    To search with regular expressions, set `regex=True`.
105
106    The value `replacements` specifies the number of replacements to perform:
107    1 to replace only the first keyword found, 2, 3...
108    Use negative values to replace from the end of the file,
109    eg. to replace the last found key, use `replacements=-1`.
110    To replace all values, set `replacements = 0`, which is the value by default.
111
112    ```
113    line... key ...line -> line... text ...line
114    ```
115    """
116    file_path = file.get(filepath)
117    if regex:
118        positions = find.pos_regex(file_path, key, replacements)
119    else:
120        positions = find.pos(file_path, key, replacements)
121    positions.reverse()  # Must start replacing from the end, otherwise the atual positions may change!
122    with open(file_path, 'r+') as f:
123        content = f.read()
124        for start, end in positions:
125            content = "".join([content[:start], text, content[end:]])
126        f.seek(0)
127        f.write(content)
128        f.truncate()
129    return None
130
131
132def replace_line(
133        filepath:str,
134        key:str,
135        text:str,
136        replacements:int=0,
137        skips:int=0,
138        additional:int=0,
139        regex:bool=False,
140        raise_errors:bool=False,
141    ) -> None:
142    """Replaces the entire line(s) containing the `key` with the `text` in `filepath`.
143
144    It can be used to delete line(s) by setting `text=''`.
145    Regular expressions can be used with `regex=True`.
146
147    The value `replacements` specifies the number of lines to replace:
148    1 to replace only the first line with the keyword, 2, 3...
149    Use negative values to replace from the end of the file,
150    e.g., to replace only the last line containing the keyword, use `replacements = -1`.
151    To replace all lines, set `replacements = 0`, which is the value by default.
152
153    The default line to replace is the matching line,
154    but it can be any other specific line after or before the matching line;
155    this is indicated with `skips` as a positive or negative integer.
156
157    More lines can be replaced with `additional` lines (int).
158    Note that the matched line plus the additional lines
159    will be replaced, this is, additional lines +1.
160
161    If the `key` is not found, an optional error can be raised with `raise_errors=True`.
162    """
163    file_path = file.get(filepath)
164    if regex:
165        positions = find.pos_regex(file_path, key, replacements)
166    else:
167        positions = find.pos(file_path, key, replacements)
168    positions.reverse()  # Must start replacing from the end, otherwise the atual positions may change!
169    if positions == [] and raise_errors:
170        raise ValueError(f'The line could not be replaced because the following key was not found:\n{key}')
171    # Open the file in read-write mode
172    with open(file_path, 'r+b') as f:
173        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_WRITE) as mm:
174            for position in positions:
175                # Get the positions of the full line containing the match
176                line_start, line_end = find.line_pos(mm, position, skips)
177                # Additional lines
178                if additional > 0:
179                    for _ in range(abs(additional)):
180                        line_end = mm.find(b'\n', line_end + 1, len(mm)-1)
181                        if line_end == -1:
182                            line_end = len(mm) - 1
183                            break
184                elif additional < 0:
185                    for _ in range(abs(additional)):
186                        line_start = mm.rfind(b'\n', 0, line_start - 1) + 1
187                        if line_start == -1:
188                            line_start = 0
189                            break
190                # Replace the line
191                old_line = mm[line_start:line_end]
192                new_line = text.encode()
193                if text == '':  # Delete the line, and the extra \n
194                    remaining_content = mm[line_end:]
195                    mm.resize(len(mm) - len(old_line) - 1)
196                    mm[line_start-1:] = remaining_content
197                # Directly modify the memory-mapped region
198                elif len(new_line) == len(old_line):
199                    mm[line_start:line_end] = new_line
200                else:  # Adjust content for differing line sizes
201                    remaining_content = mm[line_end:]
202                    updated_content = new_line + remaining_content
203                    mm.resize(len(mm) + len(new_line) - len(old_line))
204                    mm[line_start:] = updated_content
205    return None
206
207
208def replace_between(
209        filepath:str,
210        key1:str,
211        key2:str,
212        text:str,
213        delete_keys:bool=False,
214        from_end:bool=False,
215        regex:bool=False
216    ) -> None:
217    """Replace with `text` between keywords `key1` and `key2` in `filepath`.
218
219    It can be used to delete the text between the keys by setting `text=''`.
220    Regular expressions can be used by setting `regex=True`.
221
222    Key lines are also deleted if `delete_keys=True`.
223
224    Only the first matches of the keywords are used by default;
225    you can use the last ones with `from_end = True`.
226    ```
227    lines...
228    key1
229    text
230    key2
231    lines...
232    ```
233    """
234    file_path = file.get(filepath)
235    index = 1
236    if from_end:
237        index = -1
238    start, end = find.between_pos(file_path, key1, key2, delete_keys, index, regex)
239    with open(file_path, 'r+b') as f:
240        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_WRITE) as mm:
241            # Replace the line
242            old_content = mm[start:end]
243            new_content = text.encode()
244            if text == '':  # Delete the line, and the extra \n
245                remaining_content = mm[end:]
246                mm.resize(len(mm) - len(old_content) - 1)
247                mm[start-1:] = remaining_content
248            # Directly modify the memory-mapped region
249            elif len(new_content) == len(old_content):
250                mm[start:end] = new_content
251            else:  # Adjust the content for differing line sizes
252                remaining_content = mm[end:]
253                updated_content = new_content + remaining_content
254                mm.resize(len(mm) + len(new_content) - len(old_content))
255                mm[start:] = updated_content
256    return None
257
258
259def delete_under(
260        filepath,
261        key:str,
262        match:int=1,
263        skips:int=0,
264        regex:bool=False
265    ) -> None:
266    """Deletes all the content under the line containing the `key` in `filepath`.
267
268    The keyword can be at any position within the line.
269    Regular expressions can be used by setting `regex=True`.
270
271    By default the first `match` is used; it can be any positive integer (0 is treated as 1!),
272    including negative integers to select a match starting from the end of the file.
273
274    The content can be deleted after a specific number of lines after the match,
275    changing the value `skips`, that skips the specified number of lines.
276    Negative integers start deleting the content from the previous lines.
277    """
278    file_path = file.get(filepath)
279    if match == 0:
280        match = 1
281    if regex:
282        positions = find.pos_regex(file_path, key, match)
283    else:
284        positions = find.pos(file_path, key, match)
285    if match > 0:  # We only want one match, and should be the last if matches > 0
286        positions.reverse()
287    position = positions[0]
288    # Open the file in read-write mode
289    with open(file_path, 'r+b') as f:
290        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_WRITE) as mm:
291            # Get the places to insert the text
292            start, end = find.line_pos(mm, position, skips)
293            mm.resize(len(mm) - len(mm[end:]))
294            mm[end:] = b''
295    return None
296
297
298def correct_with_dict(
299        filepath:str,
300        correct:dict
301    ) -> None:
302    """Corrects the given text file `filepath` using a `correct` dictionary."""
303    file_path = file.get(filepath)
304    with open(file_path, 'r+') as f:
305        content = f.read()
306        for key, value in correct.items():
307            content = content.replace(key, value)
308        f.seek(0)
309        f.write(content)
310        f.truncate()
311    return None
312
313
314def from_template(
315        old:str,
316        new:str,
317        correct:dict=None,
318        comment:str=None,
319    ) -> None:
320    """Creates `new` file from `old`, replacing values from a `correct` dict, inserting a `comment` on top."""
321    shutil.copy(old, new)
322    if comment:
323        insert_at(new, comment, 0)
324    if correct:
325        correct_with_dict(new, correct)
326    return None