"""Extracting and changing portions of the current line

All functions take cursor offset from the beginning of the line and the line of

Python code, and return None, or a tuple of the start index, end index, and the

word."""

import re

from dataclasses import dataclass

from itertools import chain

from .lazyre import LazyReCompile

@dataclass

class LinePart:

start: int

stop: int

word: str

_current_word_re = LazyReCompile(r"(?<![)\]\w_.])" r"([\w_][\w0-9._]*[(]?)")

CHARACTER_PAIR_MAP = {"(": ")", "{": "}", "[": "]", "'": "'", '"': '"'}

def current_word(cursor_offset: int, line: str) -> LinePart | None:

"""the object.attribute.attribute just before or under the cursor"""

start = cursor_offset

end = cursor_offset

word = None

for m in _current_word_re.finditer(line):

if m.start(1) < cursor_offset <= m.end(1):

start = m.start(1)

end = m.end(1)

word = m.group(1)

if word is None:

return None

return LinePart(start, end, word)

# pieces of regex to match repr() of several hashable built-in types

_match_all_dict_keys = r"""[^\]]*"""

# https://docs.python.org/3/reference/lexical_analysis.html#string-and-bytes-literals

_match_single_quote_str_bytes = r"""

# bytes repr() begins with `b` character; bytes and str begin with `'`

b?'

# match escape sequence; this handles `\'` in the string repr()

(?:\\['"nabfrtvxuU\\]|

# or match any non-`\` and non-single-quote character (most of the string)

[^'\\])*

# matches hanging `\` or ending `'` if one is present

[\\']?

"""

# bytes and str repr() only uses double quotes if the string contains 1 or more

# `'` character and exactly 0 `"` characters

_match_double_quote_str_bytes = r"""

# bytes repr() begins with `b` character

b?"

# string continues until a `"` character is reached

[^"]*

# end matching at closing double-quote if one is present

"?"""

# match valid identifier name followed by `[` character

_match_dict_before_key = r"""[\w_][\w0-9._]*\["""

_current_dict_key_re = LazyReCompile(

f"{_match_dict_before_key}((?:"

f"{_match_single_quote_str_bytes}|"

f"{_match_double_quote_str_bytes}|"

f"{_match_all_dict_keys}|)*)",

re.VERBOSE,

)

def current_dict_key(cursor_offset: int, line: str) -> LinePart | None:

"""If in dictionary completion, return the current key"""

for m in _current_dict_key_re.finditer(line):

if m.start(1) <= cursor_offset <= m.end(1):

return LinePart(m.start(1), m.end(1), m.group(1))

return None

# capture valid identifier name if followed by `[` character

_capture_dict_name = r"""([\w_][\w0-9._]*)\["""

_current_dict_re = LazyReCompile(

f"{_capture_dict_name}((?:"

f"{_match_single_quote_str_bytes}|"

f"{_match_double_quote_str_bytes}|"

f"{_match_all_dict_keys}|)*)",

re.VERBOSE,

)

def current_dict(cursor_offset: int, line: str) -> LinePart | None:

"""If in dictionary completion, return the dict that should be used"""

for m in _current_dict_re.finditer(line):

if m.start(2) <= cursor_offset <= m.end(2):

return LinePart(m.start(1), m.end(1), m.group(1))

return None

_current_string_re = LazyReCompile(

'''(?P<open>(?:""")|"|(?:''\')|')(?:((?P<closed>.+?)(?P=open))|'''

"""(?P<unclosed>.+))"""

)

def current_string(cursor_offset: int, line: str) -> LinePart | None:

"""If inside a string of nonzero length, return the string (excluding

quotes)

Weaker than bpython.Repl's current_string, because that checks that a

string is a string based on previous lines in the buffer."""

for m in _current_string_re.finditer(line):

i = 3 if m.group(3) else 4

if m.start(i) <= cursor_offset <= m.end(i):

return LinePart(m.start(i), m.end(i), m.group(i))

return None

_current_object_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]")

def current_object(cursor_offset: int, line: str) -> LinePart | None:

"""If in attribute completion, the object on which attribute should be

looked up."""

match = current_word(cursor_offset, line)

if match is None:

return None

s = ".".join(

m.group(1)

for m in _current_object_re.finditer(match.word)

if m.end(1) + match.start < cursor_offset

)

if not s:

return None

return LinePart(match.start, match.start + len(s), s)

_current_object_attribute_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]?")

def current_object_attribute(cursor_offset: int, line: str) -> LinePart | None:

"""If in attribute completion, the attribute being completed"""

# TODO replace with more general current_expression_attribute

match = current_word(cursor_offset, line)

if match is None:

return None

matches = _current_object_attribute_re.finditer(match.word)

next(matches)

for m in matches:

if m.start(1) + match.start <= cursor_offset <= m.end(1) + match.start:

return LinePart(

m.start(1) + match.start, m.end(1) + match.start, m.group(1)

)

return None

_current_from_import_from_re = LazyReCompile(

r"from +([\w0-9_.]*)(?:\s+import\s+([\w0-9_]+[,]?\s*)+)*"

)

def current_from_import_from(cursor_offset: int, line: str) -> LinePart | None:

"""If in from import completion, the word after from

returns None if cursor not in or just after one of the two interesting

parts of an import: from (module) import (name1, name2)

"""

# TODO allow for as's

for m in _current_from_import_from_re.finditer(line):

if (m.start(1) < cursor_offset <= m.end(1)) or (

m.start(2) < cursor_offset <= m.end(2)

):

return LinePart(m.start(1), m.end(1), m.group(1))

return None

_current_from_import_import_re_1 = LazyReCompile(

r"from\s+([\w0-9_.]*)\s+import"

)

_current_from_import_import_re_2 = LazyReCompile(r"([\w0-9_]+)")

_current_from_import_import_re_3 = LazyReCompile(r", *([\w0-9_]*)")

def current_from_import_import(

cursor_offset: int, line: str

) -> LinePart | None:

"""If in from import completion, the word after import being completed

returns None if cursor not in or just after one of these words

"""

baseline = _current_from_import_import_re_1.search(line)

if baseline is None:

return None

match1 = _current_from_import_import_re_2.search(line[baseline.end() :])

if match1 is None:

return None

for m in chain(

(match1,),

_current_from_import_import_re_3.finditer(line[baseline.end() :]),

):

start = baseline.end() + m.start(1)

end = baseline.end() + m.end(1)

if start < cursor_offset <= end:

return LinePart(start, end, m.group(1))

return None

_current_import_re_1 = LazyReCompile(r"import")

_current_import_re_2 = LazyReCompile(r"([\w0-9_.]+)")

_current_import_re_3 = LazyReCompile(r"[,][ ]*([\w0-9_.]*)")

def current_import(cursor_offset: int, line: str) -> LinePart | None:

# TODO allow for multiple as's

baseline = _current_import_re_1.search(line)

if baseline is None:

return None

match1 = _current_import_re_2.search(line[baseline.end() :])

if match1 is None:

return None

for m in chain(

(match1,), _current_import_re_3.finditer(line[baseline.end() :])

):

start = baseline.end() + m.start(1)

end = baseline.end() + m.end(1)

if start < cursor_offset <= end:

return LinePart(start, end, m.group(1))

return None

_current_method_definition_name_re = LazyReCompile(r"def\s+([a-zA-Z_][\w]*)")

def current_method_definition_name(

cursor_offset: int, line: str

) -> LinePart | None:

"""The name of a method being defined"""

for m in _current_method_definition_name_re.finditer(line):

if m.start(1) <= cursor_offset <= m.end(1):

return LinePart(m.start(1), m.end(1), m.group(1))

return None

_current_single_word_re = LazyReCompile(r"(?<![.])\b([a-zA-Z_][\w]*)")

def current_single_word(cursor_offset: int, line: str) -> LinePart | None:

"""the un-dotted word just before or under the cursor"""

for m in _current_single_word_re.finditer(line):

if m.start(1) <= cursor_offset <= m.end(1):

return LinePart(m.start(1), m.end(1), m.group(1))

return None

def current_dotted_attribute(cursor_offset: int, line: str) -> LinePart | None:

"""The dotted attribute-object pair before the cursor"""

match = current_word(cursor_offset, line)

if match is not None and "." in match.word[1:]:

return match

return None

_current_expression_attribute_re = LazyReCompile(

r"[.]\s*((?:[\w_][\w0-9_]*)|(?:))"

)

def current_expression_attribute(

cursor_offset: int, line: str

) -> LinePart | None:

"""If after a dot, the attribute being completed"""

# TODO replace with more general current_expression_attribute

for m in _current_expression_attribute_re.finditer(line):

if m.start(1) <= cursor_offset <= m.end(1):

return LinePart(m.start(1), m.end(1), m.group(1))

return None

def cursor_on_closing_char_pair(

cursor_offset: int, line: str, ch: str | None = None

) -> tuple[bool, bool]:

"""Checks if cursor sits on closing character of a pair

and whether its pair character is directly behind it

"""

on_closing_char, pair_close = False, False

if line is None:

return on_closing_char, pair_close

if cursor_offset < len(line):

cur_char = line[cursor_offset]

if cur_char in CHARACTER_PAIR_MAP.values():

on_closing_char = True if ch is None else cur_char == ch

if cursor_offset > 0:

prev_char = line[cursor_offset - 1]

if (

on_closing_char

and prev_char in CHARACTER_PAIR_MAP

and CHARACTER_PAIR_MAP[prev_char] == cur_char

):

pair_close = True if ch is None else prev_char == ch

return on_closing_char, pair_close