textpy 0.0.0__py2.py3-none-any.whl

textpy/__init__.py

@@ -0,0 +1,55 @@
+import warnings
+
+__all__ = []
+
+# import `abc` if exists
+try:
+    from . import abc
+
+    __all__.extend(abc.__all__)
+    from .abc import *
+
+except ImportError as e:
+    if isinstance(e, ModuleNotFoundError):
+        raise e
+    else:
+        warnings.warn(e.msg, Warning)
+
+# import `core` if exists
+try:
+    from . import core
+
+    __all__.extend(core.__all__)
+    from .core import *
+
+except ImportError as e:
+    if isinstance(e, ModuleNotFoundError):
+        raise e
+    else:
+        warnings.warn(e.msg, Warning)
+
+# import `element` if exists
+try:
+    from . import element
+
+    __all__.extend(element.__all__)
+    from .element import *
+
+except ImportError as e:
+    if isinstance(e, ModuleNotFoundError):
+        raise e
+    else:
+        warnings.warn(e.msg, Warning)
+
+# import `format` if exists
+try:
+    from . import format
+
+    __all__.extend(format.__all__)
+    from .format import *
+
+except ImportError as e:
+    if isinstance(e, ModuleNotFoundError):
+        raise e
+    else:
+        warnings.warn(e.msg, Warning)

textpy/__version__.py

@@ -0,0 +1,3 @@
+VERSION = (0, 0, 0)
+
+__version__ = ".".join(map(str, VERSION))

textpy/abc.py

@@ -0,0 +1,452 @@
+import re
+from abc import ABC, abstractclassmethod
+from functools import cached_property
+from pathlib import Path
+from typing import *
+
+import attrs
+import pandas as pd
+from pandas.io.formats.style import Styler
+
+from .utils.re_extended import pattern_inreg, real_findall
+
+__all__ = ["PyText", "Docstring"]
+
+
+@attrs.define(auto_attribs=False)
+class PyText(ABC):
+    text: str = ""
+    name: str = ""
+    path: Path = Path("NULL.py")
+    parent: Union["PyText", None] = None
+    start_line: int = 0
+    spaces: int = 0
+
+    @abstractclassmethod
+    def __init__(self):
+        """Abstract class for python code analysis."""
+        pass
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}('{self.absname}')"
+
+    @cached_property
+    def doc(self) -> "Docstring":
+        """
+        Docstring of a function / class / method.
+
+        Returns
+        -------
+        Docstring
+            An instance of `Docstring`.
+
+        """
+        return Docstring("")
+
+    @cached_property
+    def header(self) -> "PyText":
+        """
+        Header of a class or a file.
+
+        Returns
+        -------
+        TextPy
+            An instance of `TextPy`.
+
+        """
+        return self.__class__("", parent=self)
+
+    @cached_property
+    def children_dict(self) -> Dict[str, "PyText"]:
+        """
+        Dictionary of children nodes.
+
+        Returns
+        -------
+        Dict[str, TextPy]
+            Dictionary of children nodes.
+
+        """
+        return {}
+
+    @cached_property
+    def children(self) -> List["PyText"]:
+        """
+        List of children nodes.
+
+        Returns
+        -------
+        Dict[str, TextPy]
+            List of children nodes.
+
+        """
+        return list(self.children_dict.values())
+
+    @cached_property
+    def absname(self) -> str:
+        """
+        Returns a full-name including all the parent's name, connected with
+        `"."`'s.
+
+        Returns
+        -------
+        str
+            Absolute name.
+
+        """
+        if self.parent is None:
+            return self.name
+        else:
+            return self.parent.absname + ("." + self.name).replace(".NULL", "")
+
+    @cached_property
+    def relname(self) -> str:
+        """
+        Differences to `absname` that it doesn't include the top parent's name.
+
+        Returns
+        -------
+        str
+            Relative name.
+
+        """
+        return self.absname.split(".", maxsplit=1)[-1]
+
+    @cached_property
+    def abspath(self) -> Path:
+        """
+        The absolute path of `self`.
+
+        Returns
+        -------
+        Path
+            Absolute path.
+
+        """
+        return self.path.absolute()
+
+    @cached_property
+    def relpath(self) -> Path:
+        """
+        Find the relative path to `home`.
+
+        Returns
+        -------
+        Path
+            Relative path.
+
+        """
+        if self.path.stem == "NULL":
+            return self.path if self.parent is None else self.parent.relpath
+        else:
+            return self.path.absolute().relative_to(self.path.home())
+
+    def findall(
+        self, pattern: str, regex: bool = True, styler: bool = True
+    ) -> Union[Styler, "FindTextResult"]:
+        """
+        Search for `pattern`.
+
+        Parameters
+        ----------
+        pattern : str
+            Pattern string.
+        regex : bool, optional
+            Whether to use regular expression, by default True.
+        styler : bool, optional
+            Whether to return a `Styler` object in convenience of displaying
+            in a Jupyter notebook, by default True.
+
+        Returns
+        -------
+        Union[Styler, FindTextResult]
+            Searching result.
+
+        Raises
+        ------
+        ValueError
+            Raised when `pattern` ends with a '\\\\'.
+
+        """
+        if len(pattern) > 0 and pattern[-1] == "\\":
+            raise ValueError(f"pattern should not end with a '\\': {pattern}")
+        if not regex:
+            pattern = pattern_inreg(pattern)
+        res = FindTextResult(pattern)
+        if self.children == []:
+            to_match = self.text
+            for _line, _, _group in real_findall(
+                ".*" + pattern + ".*", to_match, linemode=True
+            ):
+                if _group != "":
+                    res.append((self, self.start_line + _line - 1, _group))
+        else:
+            res = res.join(self.header.findall(pattern, styler=False))
+            for c in self.children:
+                res = res.join(c.findall(pattern, styler=False))
+        if styler:
+            return res.to_styler()
+        else:
+            return res
+
+    def jumpto(self, target: str) -> "PyText":
+        """
+        Jump to another `TextPy` instance.
+
+        Parameters
+        ----------
+        target : str
+            Relative name of the target instance.
+
+        Returns
+        -------
+        TextPy
+            An instance of `TextPy`.
+
+        Raises
+        ------
+        ValueError
+            Raised when `target` doesn't exist.
+
+        """
+        if target == "":
+            return self
+        splits = re.split("\.", target, maxsplit=1)
+        if len(splits) == 1:
+            splits.append("")
+        if self.name == splits[0]:
+            return self.jumpto(splits[1])
+        elif splits[0] == "":
+            if self.parent is not None:
+                return self.parent.jumpto(splits[1])
+            raise ValueError(f"`{self.absname}` hasn't got a parent")
+        else:
+            if splits[0] in self.children_dict:
+                return self.children_dict[splits[0]].jumpto(splits[1])
+            raise ValueError(f"`{splits[0]}` is not a child of `{self.absname}`")
+
+    def as_header(self):
+        """
+        Declare `self` as a class header (rather than the class itself).
+
+        Returns
+        -------
+        self
+            An instance of self.
+
+        """
+        self.name = "NULL"
+        return self
+
+    def track(self) -> List["PyText"]:
+        """
+        Returns a list of all the parents and `self`.
+
+        Returns
+        -------
+        List[TextPy]
+            A list of `TextPy` instances.
+
+        """
+        track: List["PyText"] = []
+        obj: Union["PyText", None] = self
+        while obj is not None:
+            track.append(obj)
+            obj = obj.parent
+        track.reverse()
+        return track
+
+
+class Docstring(ABC):
+    def __init__(self, text: str, parent: Union[PyText, None] = None):
+        """
+        Stores the docstring of a function / class / method, then divides
+        it into different sections accaording to its titles.
+
+        Parameters
+        ----------
+        text : str
+            Docstring text.
+        parent : Union[TextPy, None], optional
+            Parent node (if exists), by default None.
+
+        """
+        self.text = text.strip()
+        self.parent = parent
+
+    @cached_property
+    @abstractclassmethod
+    def sections(self) -> Dict[str, str]:
+        """
+        Returns the details of the docstring, each title corresponds to a
+        paragraph of description.
+
+        Returns
+        -------
+        Dict[str, str]
+            Dict of titles and descriptions.
+
+        """
+        return {}
+
+
+class FindTextResult:
+    def __init__(self, pattern: str):
+        """
+        Result of text finding, only as a return of `TextPy.find_text`.
+
+        Parameters
+        ----------
+        pattern : str
+            Pattern string.
+
+        """
+        self.pattern = pattern
+        self.res: List[Tuple[PyText, int, str]] = []
+
+    def __repr__(self) -> str:
+        string: str = ""
+        for _tp, _n, _group in self.res:
+            string += f"\n{_tp.relpath}:{_n}: "
+            _sub = re.sub(
+                self.pattern,
+                lambda x: "\033[100m" + x.group() + "\033[0m",
+                " " * _tp.spaces + _group,
+            )
+            string += re.sub("\\\\x1b\[", "\033[", _sub.__repr__())
+        return string.lstrip()
+
+    def append(self, finding: Tuple[PyText, int, str]):
+        """
+        Append a new finding.
+
+        Parameters
+        ----------
+        finding : Tuple[TextPy, int, str]
+            Contains a `TextPy` instance, the line number where pattern
+            is found, and a matched string.
+
+        """
+        self.res.append(finding)
+
+    def extend(self, findings: List[Tuple[PyText, int, str]]):
+        """
+        Extend a few new findings.
+
+        Parameters
+        ----------
+        findings : List[Tuple[TextPy, int, str]]
+            A finding contains a `TextPy` instance, the line number where
+            pattern is found, and a matched string.
+
+        """
+        self.res.extend(findings)
+
+    def join(self, other: "FindTextResult") -> "FindTextResult":
+        """
+        Joins two `FindTextResult` instance, only works when they share the
+        same `pattern`.
+
+        Parameters
+        ----------
+        other : FindTextResult
+            The other instance.
+
+        Returns
+        -------
+        FindTextResult
+            A new instance.
+
+        Raises
+        ------
+        ValueError
+            Raised when the two instances have different patterns.
+
+        """
+        if other.pattern != self.pattern:
+            raise ValueError("joined instances must have the same pattern")
+        obj = self.__class__(self.pattern)
+        obj.extend(self.res + other.res)
+        return obj
+
+    def to_styler(self) -> Styler:
+        """
+        Convert `self` to a dataframe `Styler` in convenience of displaying
+        in a Jupyter notebook.
+
+        Returns
+        -------
+        Styler
+            A dataframe `Styler`.
+
+        """
+        df = pd.DataFrame("", index=range(len(self.res)), columns=["source", "match"])
+        for i in range(len(self.res)):
+            _tp, _n, _match = self.res[i]
+            df.iloc[i, 0] = ".".join(
+                [
+                    "NULL"
+                    if x.name == "NULL"
+                    else make_ahref(
+                        f"{x.relpath}:{x.start_line}:{1+x.spaces}",
+                        x.name,
+                        color="inherit",
+                    )
+                    for x in _tp.track()
+                ]
+            ).replace(".NULL", "")
+            df.iloc[i, 0] += ":" + make_ahref(
+                f"{_tp.relpath}:{_n}", str(_n), color="inherit"
+            )
+            df.iloc[i, 1] = re.sub(
+                self.pattern,
+                lambda x: ""
+                if x.group() == ""
+                else make_ahref(
+                    f"{_tp.relpath}:{_n}:{1+_tp.spaces+x.span()[0]}",
+                    x.group(),
+                    color="#cccccc",
+                    background_color="#595959",
+                ),
+                _match,
+            )
+        return (
+            df.style.hide(axis=0)
+            .set_properties(**{"text-align": "left"})
+            .set_table_styles([dict(selector="th", props=[("text-align", "center")])])
+        )
+
+
+def make_ahref(
+    url: str,
+    display: str,
+    color: Union[str, None] = None,
+    background_color: Union[str, None] = None,
+) -> str:
+    """
+    Makes an HTML <a> tag.
+
+    Parameters
+    ----------
+    url : str
+        URL to link.
+    display : str
+        Word to display.
+    color : Union[str, None], optional
+        Text color, by default None.
+    background_color : Union[str, None], optional
+        Background color, by default None.
+
+    Returns
+    -------
+    str
+        An HTML <a> tag.
+
+    """
+    style_list = ["text-decoration:none"]
+    if color is not None:
+        style_list.append(f"color:{color}")
+    if background_color is not None:
+        style_list.append(f"background-color:{background_color}")
+    style = ";".join(style_list)
+    return f"<a href='{url}' style='{style}'>{display}</a>"

textpy/core.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import *
+
+from .abc import PyText
+from .element import PyFile, PyModule
+
+__all__ = ["textpy"]
+
+
+def textpy(path_or_text: Union[Path, str]) -> PyText:
+    """
+    Statically analyzes a python file or a python module. Each python
+    file is recommended to be formatted with `black` and `Auto Docstring
+    (numpy format)`, otherwise unexpected errors may occur.
+
+    Parameters
+    ----------
+    path_or_text : Union[Path, str]
+        File path, module path or file text.
+
+    Returns
+    -------
+    TextPy
+        A class written for python code analysis.
+
+    Raises
+    ------
+    ValueError
+        Raised when `path` is not found.
+
+    See Also
+    --------
+    PyModule : Corresponds to a python module.
+    PyFile : Contains the text of a python file.
+    PyClass : Contains the text of a class and its docstring.
+    PyMethod : Contains the text of a class method and its docstring.
+    PyFunc : Contains the text of a function and its docstring.
+    NumpyFormatDocstring : Stores a numpy-formatted docstring.
+
+    """
+    if len(path_or_text) < 256 and Path(path_or_text).exists():
+        path_or_text = Path(path_or_text)
+    if isinstance(path_or_text, str) or path_or_text.is_file():
+        return PyFile(path_or_text)
+    elif path_or_text.is_dir():
+        return PyModule(path_or_text)
+    else:
+        raise ValueError(f"path not exists: {path_or_text}")

textpy/element.py

@@ -0,0 +1,227 @@
+import re
+from functools import cached_property
+from pathlib import Path
+from typing import *
+
+from .abc import Docstring, PyText
+from .format import NumpyFormatDocstring
+from .utils.re_extended import line_count_iter, rsplit
+
+__all__ = ["PyModule", "PyFile", "PyClass", "PyFunc", "PyMethod"]
+
+
+class PyModule(PyText):
+    def __init__(self, path: Union[Path, str], parent: Union[PyText, None] = None):
+        """
+        A python module including multiple python files.
+
+        Parameters
+        ----------
+        path : Union[Path, str]
+            File path.
+        parent : Union[TextPy, None], optional
+            Parent node (if exists), by default None.
+
+        Raises
+        ------
+        NotADirectoryError
+            Raised when `path` is not a directory.
+
+        """
+        self.path = Path(path)
+        if not self.path.is_dir():
+            raise NotADirectoryError(f"not a dicretory: '{self.path}'")
+        self.name = self.path.stem
+        self.parent = parent
+
+    @cached_property
+    def header(self) -> PyText:
+        return PyFile("", parent=self)
+
+    @cached_property
+    def children_dict(self) -> Dict[str, PyText]:
+        children_dict: Dict[str, PyText] = {}
+        for _path in self.path.iterdir():
+            if _path.suffix == ".py":
+                children_dict[_path.stem] = PyFile(_path, parent=self)
+            elif _path.is_dir():
+                _module = PyModule(_path, parent=self)
+                if len(_module.children) > 0:
+                    children_dict[_path.stem] = _module
+        return children_dict
+
+
+class PyFile(PyText):
+    def __init__(
+        self,
+        path_or_text: Union[Path, str],
+        parent: Union[PyText, None] = None,
+        start_line: int = 1,
+    ):
+        """
+        Python file.
+
+        Parameters
+        ----------
+        path_or_text : Union[Path, str]
+            File path or file text.
+        parent : Union[TextPy, None], optional
+            Parent node (if exists), by default None.
+
+        """
+        if isinstance(path_or_text, Path):
+            self.path = path_or_text
+            print(self.path)
+            self.text = self.path.read_text().strip()
+        else:
+            self.text = path_or_text.strip()
+
+        self.name = self.path.stem
+        self.parent = parent
+        self.start_line = start_line
+        self.__header: Union[str, None] = None
+
+    @cached_property
+    def header(self) -> PyText:
+        if self.__header is None:
+            _ = self.children_dict
+        return self.__class__(self.__header, parent=self).as_header()
+
+    @cached_property
+    def children_dict(self) -> Dict[str, PyText]:
+        children_dict: Dict[str, PyText] = {}
+        _cnt: int = 0
+        self.__header = ""
+        for i, _text in line_count_iter(rsplit("\n\n\n", self.text)):
+            _text = "\n" + _text.strip()
+            if re.match("(?:\n@.*)*\ndef ", _text):
+                _node = PyFunc(_text, parent=self, start_line=int(i + 3 * (_cnt > 0)))
+                children_dict[_node.name] = _node
+            elif re.match("(?:\n@.*)*\nclass ", _text):
+                _node = PyClass(_text, parent=self, start_line=int(i + 3 * (_cnt > 0)))
+                children_dict[_node.name] = _node
+            elif _cnt == 0:
+                self.__header = _text
+            else:
+                _node = PyFile(_text, parent=self, start_line=int(i + 3 * (_cnt > 0)))
+                children_dict[f"NULL-{i}"] = _node
+            _cnt += 1
+        return children_dict
+
+
+class PyClass(PyText):
+    def __init__(
+        self, text: str, parent: Union[PyText, None] = None, start_line: int = 1
+    ):
+        """
+        Python class.
+
+        Parameters
+        ----------
+        text : str
+            Class text.
+        parent : Union[TextPy, None], optional
+            Parent node (if exists), by default None.
+        start_line : int, optional
+            Starting line number, by default 1.
+
+        """
+        self.text = text.strip()
+        self.name = re.search("class .*?[(:]", self.text).group()[6:-1]
+        if self.parent is not None:
+            self.path = self.parent.path
+        self.parent = parent
+        self.start_line = start_line
+        self.__header: Union[str, None] = None
+
+    @cached_property
+    def doc(self) -> Docstring:
+        if (
+            "__init__" in self.children_dict
+            and self.children_dict["__init__"].doc.text != ""
+        ):
+            _doc = self.children_dict["__init__"].doc.text
+        else:
+            _doc = self.header.text
+        return NumpyFormatDocstring(_doc, parent=self)
+
+    @cached_property
+    def header(self) -> PyText:
+        if self.__header is None:
+            _ = self.children_dict
+        return self.__class__(
+            self.__header, parent=self, start_line=self.start_line
+        ).as_header()
+
+    @cached_property
+    def children_dict(self) -> Dict[str, PyText]:
+        children_dict: Dict[str, PyText] = {}
+        sub_text = re.sub("\n    ", "\n", self.text)
+        _cnt: int = 0
+        for i, _str in line_count_iter(rsplit("(?:\n@.*)*\ndef ", sub_text)):
+            if _cnt == 0:
+                self.__header = _str.replace("\n", "\n    ")
+            else:
+                _node = PyMethod(_str, parent=self, start_line=self.start_line + i)
+                children_dict[_node.name] = _node
+            _cnt += 1
+        return children_dict
+
+
+class PyFunc(PyText):
+    def __init__(
+        self, text: str, parent: Union[PyText, None] = None, start_line: int = 1
+    ):
+        """
+        Python function.
+
+        Parameters
+        ----------
+        text : str
+            Funtion text.
+        parent : Union[TextPy, None], optional
+            Parent node (if exists), by default None.
+        start_line : int, optional
+            Starting line number, by default 1.
+
+        """
+        self.text = text.strip()
+        self.name = re.search("def .*?\(", self.text).group()[4:-1]
+        if self.parent is not None:
+            self.path = self.parent.path
+        self.parent = parent
+        self.start_line = start_line
+
+    @cached_property
+    def doc(self) -> Docstring:
+        searched = re.search('""".*?"""', self.text, re.DOTALL)
+        if searched:
+            _doc = re.sub("\n    ", "\n", searched.group()[3:-3])
+        else:
+            _doc = ""
+        return NumpyFormatDocstring(_doc, parent=self)
+
+    @cached_property
+    def header(self) -> PyText:
+        raise NotImplementedError("`PyFunc.header` not implemented yet")
+
+
+class PyMethod(PyFunc):
+    def __init__(
+        self, text: str, parent: Union[PyText, None] = None, start_line: int = 1
+    ):
+        """
+        Python class method.
+
+        Parameters
+        ----------
+        text : str
+            Method text.
+        parent : Union[TextPy, None], optional
+            Parent node (if exists), by default None.
+        start_line : int, optional
+            Starting line number, by default 1.
+
+        """
+        super().__init__(text, parent=parent, start_line=start_line)
+        self.spaces = 4

textpy/format.py

@@ -0,0 +1,21 @@
+import re
+from functools import cached_property
+from typing import *
+
+from .abc import Docstring
+from .utils.re_extended import rsplit
+
+__all__ = ["NumpyFormatDocstring"]
+
+
+class NumpyFormatDocstring(Docstring):
+    @cached_property
+    def sections(self) -> Dict[str, str]:
+        details: Dict[str, str] = {}
+        for i, _str in enumerate(rsplit(".*\n-+\n", self.text)):
+            if i == 0:
+                details["_header_"] = _str.strip()
+            else:
+                _key, _value = re.split("\n-+\n", _str, maxsplit=1)
+                details[_key] = _value.strip()
+        return details

textpy/utils/__init__.py

@@ -0,0 +1,16 @@
+import warnings
+
+__all__ = []
+
+# import `re_extended` if exists
+try:
+    from . import re_extended
+
+    __all__.extend(re_extended.__all__)
+    from .re_extended import *
+
+except ImportError as e:
+    if isinstance(e, ModuleNotFoundError):
+        raise e
+    else:
+        warnings.warn(e.msg, Warning)

textpy/utils/re_extended.py

@@ -0,0 +1,237 @@
+import re
+from typing import *
+
+SpanNGroup = Tuple[Tuple[int, int], str]
+LineSpanNGroup = Tuple[int, Tuple[int, int], str]
+
+__all__ = [
+    "rsplit",
+    "lsplit",
+    "real_findall",
+    "pattern_inreg",
+    "line_count",
+    "line_count_iter",
+]
+
+
+def rsplit(
+    pattern: Union[str, re.Pattern],
+    string: str,
+    maxsplit: int = 0,
+    flags: Union[int, re.RegexFlag] = 0,
+) -> List[str]:
+    """
+    Split the string by the occurrences of the pattern. Differences to
+    `re.split` that the text of all groups in the pattern are also
+    returned, each followed by a substring on its right, connected with
+    `""`'s.
+
+    Parameters
+    ----------
+    pattern : Union[str, re.Pattern]
+        Pattern string.
+    string : str
+        String to be splitted.
+    maxsplit : int, optional
+        Max number of splits, if specified to be 0, there will be no
+        more limits, by default 0.
+    flags : Union[int, re.RegexFlag], optional
+        Regex flag, by default 0.
+
+    Returns
+    -------
+    List[str]
+        List of substrings.
+
+    """
+    splits: List[str] = []
+    searched = re.search(pattern, string, flags=flags)
+    _lstr: str = ""
+    while searched:
+        _span = searched.span()
+        splits.append(_lstr + string[: _span[0]])
+        _lstr = searched.group()
+        string = string[_span[1] :]
+        if maxsplit > 0 and len(splits) >= maxsplit:
+            break
+        searched = re.search(pattern, string, flags=flags)
+    splits.append(_lstr + string)
+    return splits
+
+
+def lsplit(
+    pattern: Union[str, re.Pattern],
+    string: str,
+    maxsplit: int = 0,
+    flags: Union[int, re.RegexFlag] = 0,
+) -> List[str]:
+    """
+    Split the string by the occurrences of the pattern. Differences to
+    `re.split` that the text of all groups in the pattern are also
+    returned, each following a substring on its left, connected with
+    `""`'s.
+
+    Parameters
+    ----------
+    pattern : Union[str, re.Pattern]
+        Pattern string.
+    string : str
+        String to be splitted.
+    maxsplit : int, optional
+        Max number of splits, if specified to be 0, there will be no
+        more limits, by default 0.
+    flags : Union[int, re.RegexFlag], optional
+        Regex flag, by default 0.
+
+    Returns
+    -------
+    List[str]
+        List of substrings.
+
+    """
+    splits: List[str] = []
+    searched = re.search(pattern, string, flags=flags)
+    while searched:
+        _span = searched.span()
+        splits.append(string[: _span[1]])
+        string = string[_span[1] :]
+        if maxsplit > 0 and len(splits) >= maxsplit:
+            break
+        searched = re.search(pattern, string, flags=flags)
+    splits.append(string)
+    return splits
+
+
+def real_findall(
+    pattern: Union[str, re.Pattern],
+    string: str,
+    flags: Union[int, re.RegexFlag] = 0,
+    linemode: bool = False,
+) -> List[Union[SpanNGroup, LineSpanNGroup]]:
+    """
+    Finds all non-overlapping matches in the string. Differences to
+    `re.findall` that it also returns the spans of patterns.
+
+    Parameters
+    ----------
+    pattern : Union[str, re.Pattern]
+        Pattern string.
+    string : str
+        String to be searched.
+    flags : Union[int, re.RegexFlag], optional
+        Regex flag, by default 0.
+    linemode : bool, optional
+        If true, match the pattern on each line of the string, by
+        default False.
+
+    Returns
+    -------
+    List[Union[SpanNGroup, LineSpanNGroup]]
+        List of finding result. If `linemode` is false, each list
+        element consists of the span and the group of the pattern. If
+        `linemode` is true, each list element consists of the line
+        number, the span (within the line), and the group of the
+        pattern instead.
+
+    """
+    finds: List[SpanNGroup] = []
+    _sum: int = 0
+    _line: int = 1
+    _inline_pos: int = 0
+    searched = re.search(pattern, string, flags=flags)
+    while searched:
+        _len_string = len(string)
+        _span, _group = searched.span(), searched.group()
+        if linemode:
+            _lsting = string[: _span[0]]
+            _lline = line_count(_lsting) - 1
+            _line += _lline
+            if _lline > 0:
+                _inline_pos = 0
+            _lastline_pos = len(_lsting) - 1 - _lsting.rfind("\n")
+            finds.append(
+                (
+                    _line,
+                    (
+                        _inline_pos + _lastline_pos,
+                        _inline_pos + _lastline_pos + _span[1] - _span[0],
+                    ),
+                    _group,
+                )
+            )
+            _line += line_count(_group) - 1
+            if "\n" in _group:
+                _inline_pos = len(_group) - 1 - _group.rfind("\n")
+            else:
+                _inline_pos += max(_lastline_pos + _span[1] - _span[0], 1)
+        else:
+            finds.append(((_span[0] + _sum, _span[1] + _sum), _group))
+            _sum += max(_span[1], 1)
+        if _len_string == 0:
+            break
+        if _span[1] == 0:
+            _line += 1 if string[0] == "\n" else 0
+            string = string[1:]
+        else:
+            string = string[_span[1] :]
+        searched = re.search(pattern, string, flags=flags)  # search again
+    return finds
+
+
+def pattern_inreg(pattern: str) -> str:
+    """
+    Invalidates the regular expressions in `pattern`.
+
+    Parameters
+    ----------
+    pattern : str
+        Pattern to be invalidated.
+
+    Returns
+    -------
+    str
+        A new pattern.
+
+    """
+    return re.sub("[$^.\[\]*+-?!{},|:#><=\\\\]", lambda x: "\\" + x.group(), pattern)
+
+
+def line_count(string: str) -> int:
+    """
+    Counts the number of lines in a string.
+
+    Parameters
+    ----------
+    string : str
+        A string.
+
+    Returns
+    -------
+    int
+        Total number of lines.
+
+    """
+    return 1 + len(re.findall("\n", string))
+
+
+def line_count_iter(iter: Iterable[str]) -> Iterable[Tuple[int, str]]:
+    """
+    Counts the number of lines in each string, and returns the cumsumed
+    values.
+
+    Parameters
+    ----------
+    iter : Iterable[str]
+        An iterable of strings.
+
+    Yields
+    ------
+    Tuple[int, str]
+        Each time, yields the cumsumed number of lines til now together
+        with a string found in `iter`, until `iter` is traversed.
+
+    """
+    _cnt = 1
+    for _str in iter:
+        yield _cnt, _str
+        _cnt += len(re.findall("\n", _str))

textpy-0.0.0.dist-info/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2023, Chitaoji
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

textpy-0.0.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: textpy
+Version: 0.0.0
+Summary: Reads a python file/module and statically analyzes it.
+Home-page: https://github.com/Chitaoji/textpy
+Author: Chitaoji
+Author-email: 2360742040@qq.com
+License: BSD
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Requires-Python: >=3.8.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs
+Requires-Dist: pandas
+
+
+# textpy
+Reads a python file/module and statically analyzes it.
+
+## Installation
+
+```sh
+pip install textpy
+```
+
+## Examples
+Create a new file named `this_is_a_file.py`:
+
+```py
+class ThisIsAClass:
+    def __init__(self):
+        """Write something."""
+        self.var_1 = "hahaha"
+        self.var_2 = "blabla"
+
+
+def this_is_a_function(a: ThisIsAClass):
+    """
+    Write something.
+
+    Parameters
+    ----------
+    a : ThisIsAClass
+        An object.
+
+    """
+    print(a.var_1, a.var_2)
+```
+
+Run the following codes to find all the occurrences of the pattern `"var"` in `this_is_a_file.py`:
+
+```py
+from textpy import textpy
+
+res = textpy("this_is_a_file.py").findall("var", styler=False)
+print(res)
+# Output:
+# this_is_a_file.py:4: '        self.var_1 = "hahaha"'
+# this_is_a_file.py:5: '        self.var_2 = "blabla"'
+# this_is_a_file.py:18: '    print(a.var_1, a.var_2)'
+```
+
+Also, when using a Jupyter notebook, you can run a cell like this:
+
+```py
+from textpy import textpy
+
+textpy("this_is_a_file.py").findall("var")
+```
+
+and the output will be like:
+
+![Alt text](images/example_1.png)
+
+Now suppose you've got a python module consists of a few files, for example, our `textpy` module itself, you can do almost the same thing:
+
+```py
+module_path = "textpy/" # you can type any path here
+pattern = "note.*k" # type any regular expression here
+
+res = textpy(module_path).findall(pattern, styler=False)
+print(res)
+# Output:
+# textpy_local/textpy/abc.py:158: '            in a Jupyter notebook, by default True.'
+# textpy_local/textpy/abc.py:375: '        in a Jupyter notebook.'
+```
+## License
+This project falls under the BSD 2-Clause License.
+
+## v0.1.3
+* Initial release.

textpy-0.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+textpy/__init__.py,sha256=5oLjKa8mwM03dH5jc7526vt866trItW03Mu1azOypK0,1030
+textpy/__version__.py,sha256=O9-8j_dDi79rAllM4J_l2fbsq4NWiGnQhlf91GOgm9o,63
+textpy/abc.py,sha256=Y1bqElEbQu3JM2V5gSNnVolsGTDXVQ-2-Kc18WyqVw8,11748
+textpy/core.py,sha256=WXUi2ubSw38UOUFRUu7cvQwL8IuKYCLwIj2DnB_EIx0,1413
+textpy/element.py,sha256=uqqj3gb_L1iD51F7gCrWk56tAhp7dgw0W0ekEibakK4,7061
+textpy/format.py,sha256=SCgJ8vjdYsOR30xZUdLTnUjIj-JqLNTf13Lqy0BlOa8,607
+textpy/utils/__init__.py,sha256=77LZdb0LWdqR8GaHo6mmubcGYHCsrwRnith6adkh0Wg,304
+textpy/utils/re_extended.py,sha256=nespS2veOa7Y5akpn1qOWjh_e7b8DEAjOkCfh2PBpaE,6385
+textpy-0.0.0.dist-info/LICENSE,sha256=2mvoSaHTcgpKXSRr7Q1UeqdKB9H670-BUBH5koBypks,1297
+textpy-0.0.0.dist-info/METADATA,sha256=cp5Et1hZVVZnR9neWqAnOsxJNOKFvUlMqT7uRd9fw9Y,2227
+textpy-0.0.0.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
+textpy-0.0.0.dist-info/top_level.txt,sha256=oWHnPcR9GIzbwkj6ZR9wflWbnft6QtEx8r6MbNbSBR4,7
+textpy-0.0.0.dist-info/RECORD,,

textpy-0.0.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

textpy-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+textpy