py2ls 0.1.9.9__py3-none-any.whl → 0.1.10.1__py3-none-any.whl

py2ls/ocr.py

@@ -0,0 +1,557 @@
+import easyocr
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from py2ls.ips import (
+    strcmp,
+    detect_angle,
+)  # Ensure this function is defined in your 'ips' module
+from spellchecker import SpellChecker
+import re
+
+from PIL import Image, ImageDraw, ImageFont
+import PIL.PngImagePlugin
+
+"""
+    Optical Character Recognition (OCR)
+"""
+
+# Valid language codes
+lang_valid = {
+    "english": "en",
+    "thai": "th",
+    "chinese_traditional": "ch_tra",
+    "chinese": "ch_sim",
+    "japanese": "ja",
+    "korean": "ko",
+    "tamil": "ta",
+    "telugu": "te",
+    "kannada": "kn",
+    "german": "de",
+}
+
+
+def lang_auto_detect(lang):
+    res_lang = []
+    if isinstance(lang, str):
+        lang = [lang]
+    for i in lang:
+        res_lang.append(lang_valid[strcmp(i, list(lang_valid.keys()))[0]])
+    return res_lang
+
+
+def determine_src_points(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Sort contours by area and pick the largest one
+    contours = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
+    src_points = None
+
+    for contour in contours:
+        epsilon = 0.02 * cv2.arcLength(contour, True)
+        approx = cv2.approxPolyDP(contour, epsilon, True)
+        if len(approx) == 4:  # We need a quadrilateral
+            src_points = np.array(approx, dtype="float32")
+            break
+
+    if src_points is not None:
+        # Order points in a specific order (top-left, top-right, bottom-right, bottom-left)
+        src_points = src_points.reshape(4, 2)
+        rect = np.zeros((4, 2), dtype="float32")
+        s = src_points.sum(axis=1)
+        diff = np.diff(src_points, axis=1)
+        rect[0] = src_points[np.argmin(s)]
+        rect[2] = src_points[np.argmax(s)]
+        rect[1] = src_points[np.argmin(diff)]
+        rect[3] = src_points[np.argmax(diff)]
+        src_points = rect
+    else:
+        # If no rectangle is detected, fallback to a default or user-defined points
+        height, width = image.shape[:2]
+        src_points = np.array(
+            [[0, 0], [width - 1, 0], [width - 1, height - 1], [0, height - 1]],
+            dtype="float32",
+        )
+    return src_points
+
+
+def get_default_camera_matrix(image_shape):
+    height, width = image_shape[:2]
+    focal_length = width
+    center = (width / 2, height / 2)
+    camera_matrix = np.array(
+        [[focal_length, 0, center[0]], [0, focal_length, center[1]], [0, 0, 1]],
+        dtype="float32",
+    )
+    dist_coeffs = np.zeros((4, 1))  # Assuming no distortion
+    return camera_matrix, dist_coeffs
+
+
+def correct_perspective(image, src_points):
+    # Define the destination points for the perspective transform
+    width, height = 1000, 1000  # Adjust size as needed
+    dst_points = np.array(
+        [[0, 0], [width - 1, 0], [width - 1, height - 1], [0, height - 1]],
+        dtype="float32",
+    )
+
+    # Calculate the perspective transform matrix
+    M = cv2.getPerspectiveTransform(src_points, dst_points)
+    # Apply the perspective transform
+    corrected_image = cv2.warpPerspective(image, M, (width, height))
+    return corrected_image
+
+
+def detect_text_orientation(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+    lines = cv2.HoughLines(edges, 1, np.pi / 180, 200)
+
+    if lines is None:
+        return 0
+
+    angles = []
+    for rho, theta in lines[:, 0]:
+        angle = theta * 180 / np.pi
+        if angle > 90:
+            angle -= 180
+        angles.append(angle)
+
+    median_angle = np.median(angles)
+    return median_angle
+
+
+def rotate_image(image, angle):
+    center = (image.shape[1] // 2, image.shape[0] // 2)
+    rot_mat = cv2.getRotationMatrix2D(center, angle, 1.0)
+    rotated_image = cv2.warpAffine(
+        image, rot_mat, (image.shape[1], image.shape[0]), flags=cv2.INTER_LINEAR
+    )
+    return rotated_image
+
+
+def correct_skew(image):
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    coords = np.column_stack(np.where(gray > 0))
+    angle = cv2.minAreaRect(coords)[-1]
+    if angle < -45:
+        angle = -(90 + angle)
+    else:
+        angle = -angle
+    return rotate_image(image, angle)
+
+
+def undistort_image(image, camera_matrix, dist_coeffs):
+    return cv2.undistort(image, camera_matrix, dist_coeffs)
+
+
+def add_text_pil(image, text, position, font_size=10, color=(255, 0, 0)):
+    # Convert the image to PIL format
+    pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    # Create a drawing context
+    draw = ImageDraw.Draw(pil_image)
+    # Define the font (make sure to use a font that supports Chinese characters)
+    try:
+        font = ImageFont.truetype(
+            "/System/Library/Fonts/Supplemental/Songti.ttc", font_size
+        )
+    except IOError:
+        font = ImageFont.load_default()
+
+    # cal top_left position
+    # Measure text size using textbbox
+    text_bbox = draw.textbbox((0, 0), text, font=font)
+    text_width = text_bbox[2] - text_bbox[0]
+    text_height = text_bbox[3] - text_bbox[1]
+    # Calculate 5% of the text height for upward adjustment
+    offset = int(0.5 * text_height)  # 上移动 50%
+    # Adjust position to match OpenCV's bottom-left alignment
+    adjusted_position = (position[0], position[1] - text_height - offset)
+
+    # Add text to the image
+    draw.text(adjusted_position, text, font=font, fill=color)
+    # Convert the image back to OpenCV format
+    image = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+    return image
+
+
+def preprocess_img(
+    image,
+    grayscale=True,
+    threshold=True,
+    threshold_method="adaptive",
+    rotate="auto",
+    skew=True,
+    denoise=True,
+    blur_ksize=(5, 5),
+    morph=True,
+    morph_op="open",
+    morph_kernel_size=(3, 3),
+    enhance_contrast=True,
+    clahe_clip=2.0,
+    clahe_grid_size=(8, 8),
+    edge_detection=False,
+):
+    """
+    预处理步骤:
+
+    转换为灰度图像: 如果 grayscale 为 True，将图像转换为灰度图像。
+    二值化处理: 根据 threshold 和 threshold_method 参数，对图像进行二值化处理。
+    降噪处理: 使用高斯模糊对图像进行降噪。
+    形态学处理: 根据 morph_op 参数选择不同的形态学操作（开运算、闭运算、膨胀、腐蚀），用于去除噪声或填补孔洞。
+    对比度增强: 使用 CLAHE 技术增强图像对比度。
+    边缘检测: 如果 edge_detection 为 True，使用 Canny 边缘检测算法。
+
+    预处理图像以提高 OCR 识别准确性。
+    参数:
+    image: 输入的图像路径或图像数据。
+    grayscale: 是否将图像转换为灰度图像。
+    threshold: 是否对图像进行二值化处理。
+    threshold_method: 二值化方法，可以是 'global' 或 'adaptive'。
+    denoise: 是否对图像进行降噪处理。
+    blur_ksize: 高斯模糊的核大小。
+    morph: 是否进行形态学处理。
+    morph_op: 形态学操作的类型，包括 'open'（开运算）、'close'（闭运算）、'dilate'（膨胀）、'erode'（腐蚀）。
+    morph_kernel_size: 形态学操作的内核大小。
+    enhance_contrast: 是否增强图像对比度。
+    clahe_clip: CLAHE（对比度受限的自适应直方图均衡）的剪裁限制。
+    clahe_grid_size: CLAHE 的网格大小。
+    edge_detection: 是否进行边缘检测。
+    """
+    if isinstance(image, PIL.PngImagePlugin.PngImageFile):
+        image = np.array(image)
+    if isinstance(image, str):
+        image = cv2.imread(image)
+    if not isinstance(image, np.ndarray):
+        image = np.array(image)
+    if image.shape[1] == 4:  # Check if it has an alpha channel
+        # Drop the alpha channel (if needed), or handle it as required
+        image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
+    else:
+        # Convert RGB to BGR for OpenCV compatibility
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+    # Rotate image
+    if rotate == "auto":
+        angle = detect_angle(image, by="fft")
+        img_preprocessed = rotate_image(image, angle)
+    else:
+        img_preprocessed = image
+
+    # # Correct skew
+    # if skew:
+    #     img_preprocessed = correct_skew(image)
+
+    # Convert to grayscale
+    if grayscale:
+        img_preprocessed = cv2.cvtColor(img_preprocessed, cv2.COLOR_BGR2GRAY)
+
+    # Thresholding
+    if threshold:
+        if threshold_method == "adaptive":
+            image = cv2.adaptiveThreshold(
+                img_preprocessed,
+                255,
+                cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                cv2.THRESH_BINARY,
+                11,
+                2,
+            )
+        elif threshold_method == "global":
+            _, img_preprocessed = cv2.threshold(
+                img_preprocessed, 127, 255, cv2.THRESH_BINARY
+            )
+
+    # Denoise
+    if denoise:
+        img_preprocessed = cv2.GaussianBlur(img_preprocessed, blur_ksize, 0)
+
+    # 形态学处理
+    if morph:
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, morph_kernel_size)
+        if morph_op == "close":  # 闭运算
+            # 目的： 闭运算用于填补前景物体中的小孔或间隙，同时保留其形状和大小。
+            # 工作原理： 闭运算先进行膨胀，然后进行腐蚀。膨胀步骤填补小孔或间隙，腐蚀步骤恢复较大物体的形状。
+            # 效果：
+            # 填补前景物体中的小孔和间隙。
+            # 平滑较大物体的边缘。
+            # 示例用途： 填补物体中的小孔或间隙。
+            img_preprocessed = cv2.morphologyEx(
+                img_preprocessed, cv2.MORPH_CLOSE, kernel
+            )
+        elif morph_op == "open":  # 开运算
+            # 目的： 开运算用于去除背景中的小物体或噪声，同时保留较大物体的形状和大小。
+            # 工作原理： 开运算先进行腐蚀，然后进行膨胀。腐蚀步骤去除小规模的噪声，膨胀步骤恢复剩余物体的大小。
+            # 效果：
+            # 去除前景中的小物体。
+            # 平滑较大物体的轮廓。
+            # 示例用途： 去除小噪声或伪影，同时保持较大物体完整。
+            img_preprocessed = cv2.morphologyEx(
+                img_preprocessed, cv2.MORPH_OPEN, kernel
+            )
+        elif morph_op == "dilate":  # 膨胀
+            # 目的： 膨胀操作在物体边界上添加像素。它可以用来填补物体中的小孔或连接相邻的物体。
+            # 工作原理： 内核在图像上移动，每个位置上的像素值被设置为内核覆盖区域中的最大值。
+            # 效果：
+            # 物体变大。
+            # 填补物体中的小孔或间隙。
+            # 示例用途： 填补物体中的小孔或连接断裂的物体部分。
+            img_preprocessed = cv2.dilate(img_preprocessed, kernel)
+        elif morph_op == "erode":  # 腐蚀
+            # 目的： 腐蚀操作用于去除物体边界上的像素。它可以用来去除小规模的噪声，并将靠近的物体分开。
+            # 工作原理： 内核（结构元素）在图像上移动，每个位置上的像素值被设置为内核覆盖区域中的最小值。
+            # 效果：
+            # 物体变小。
+            # 去除图像中的小白点（在白色前景/黑色背景的图像中）。
+            # 示例用途： 去除二值图像中的小噪声或分离相互接触的物体
+            img_preprocessed = cv2.erode(img_preprocessed, kernel)
+
+    # 对比度增强
+    if enhance_contrast:
+        clahe = cv2.createCLAHE(clipLimit=clahe_clip, tileGridSize=clahe_grid_size)
+        img_preprocessed = clahe.apply(img_preprocessed)
+
+    # 边缘检测
+    if edge_detection:
+        img_preprocessed = cv2.Canny(img_preprocessed, 100, 200)
+
+    return img_preprocessed
+
+
+def text_postprocess(
+    text,
+    spell_check=True,
+    clean=True,
+    filter=dict(min_length=2),
+    pattern=None,
+    merge=True,
+):
+
+    def correct_spelling(text_list):
+        spell = SpellChecker()
+        corrected_text = [spell.candidates(word) for word in text_list]
+        return corrected_text
+
+    def clean_text(text_list):
+        cleaned_text = [re.sub(r"[^\w\s]", "", text) for text in text_list]
+        return cleaned_text
+
+    def filter_text(text_list, min_length=2):
+        filtered_text = [text for text in text_list if len(text) >= min_length]
+        return filtered_text
+
+    def extract_patterns(text_list, pattern):
+        pattern = re.compile(pattern)
+        matched_text = [text for text in text_list if pattern.search(text)]
+        return matched_text
+
+    def merge_fragments(text_list):
+        merged_text = " ".join(text_list)
+        return merged_text
+
+    results = text
+    print(results)
+    if spell_check:
+        results = correct_spelling(results)
+    if clean:
+        results = clean_text(results)
+    if filter:
+        results = filter_text(
+            results, min_length=postprocess["filter"].get("min_length", 2)
+        )
+    if pattern:
+        results = extract_patterns(results, postprocess["pattern"])
+    if merge:
+        results = merge_fragments(results)
+
+
+# https://www.jaided.ai/easyocr/documentation/
+# extract text from an image with EasyOCR
+def get_text(
+    image,
+    lang=["ch_sim", "en"],
+    thr=0.25,
+    gpu=True,
+    decoder="wordbeamsearch",  #'greedy', 'beamsearch' and 'wordbeamsearch'(hightly accurate)
+    output="all",
+    preprocess=None,
+    postprocess="not ready",
+    show=True,
+    ax=None,
+    cmap=cv2.COLOR_BGR2RGB,  # draw_box
+    font=cv2.FONT_HERSHEY_SIMPLEX,
+    fontScale=0.8,
+    thickness_text=2,  # Line thickness of 2 px
+    color_box=(0, 255, 0),  # draw_box
+    color_text=(0, 0, 255),  # draw_box
+    **kwargs,
+):
+    """
+    功能: 该函数使用 EasyOCR 进行文本识别，并允许自定义图像预处理步骤和结果展示。
+    参数:
+    image: 输入的图像路径或图像数据。
+    lang: OCR 语言列表。
+    thr: 置信度阈值，低于此阈值的检测结果将被过滤。
+    gpu: 是否使用 GPU。
+    output: 输出类型，可以是 'all'（返回所有检测结果）、'text'（返回文本）、'score'（返回置信度分数）、'box'（返回边界框）。
+    preprocess: 预处理参数字典，传递给 preprocess_img 函数。
+    show: 是否显示结果图像。
+    ax: 用于显示图像的 Matplotlib 子图。
+    cmap: 用于显示图像的颜色映射。
+    color_box: 边界框的颜色。
+    color_text: 文本的颜色。
+    kwargs: 传递给 EasyOCR readtext 函数的其他参数。
+
+    # Uage
+    image_path = 'car_plate.jpg'  # 替换为你的图像路径
+    results = get_text(
+        image_path,
+        lang=["en"],
+        gpu=False,
+        output="text",
+        preprocess={
+            "grayscale": True,
+            "threshold": True,
+            "threshold_method": 'adaptive',
+            "denoise": True,
+            "blur_ksize": (5, 5),
+            "morph": True,
+            "morph_op": 'close',
+            "morph_kernel_size": (3, 3),
+            "enhance_contrast": True,
+            "clahe_clip": 2.0,
+            "clahe_grid_size": (8, 8),
+            "edge_detection": False
+        },
+        adjust_contrast=0.7
+    )
+    """
+    lang = lang_auto_detect(lang)
+    print(f"detecting language(s):{lang}")
+    if isinstance(image, str):
+        image = cv2.imread(image)
+
+    # Ensure lang is always a list
+    if isinstance(lang, str):
+        lang = [lang]
+
+    # ! preprocessing img
+    if preprocess is None:
+        preprocess = {}
+    image_process = preprocess_img(image, **preprocess)
+
+    # Perform OCR on the image
+    reader = easyocr.Reader(lang, gpu=gpu)
+    detections = reader.readtext(image_process, decoder=decoder, **kwargs)
+    if postprocess is None:
+        postprocess = dict(
+            spell_check=True,
+            clean=True,
+            filter=dict(min_length=2),
+            pattern=None,
+            merge=True,
+        )
+        text_corr = []
+        for _, text, _ in detections:
+            text_corr.extend(text_postprocess(text, **postprocess))
+    if show:
+        if ax is None:
+            ax = plt.gca()
+        for bbox, text, score in detections:
+            if score > thr:
+                top_left = tuple(map(int, bbox[0]))
+                bottom_right = tuple(map(int, bbox[2]))
+                image = cv2.rectangle(image, top_left, bottom_right, color_box, 2)
+                # image = cv2.putText(
+                #     image, text, top_left, font, fontScale, color_text, thickness_text
+                # )
+                image = add_text_pil(
+                    image, text, top_left, font_size=fontScale * 32, color=color_text
+                )
+
+        img_cmp = cv2.cvtColor(image, cmap)
+        ax.imshow(img_cmp)
+        ax.axis("off")
+        # plt.show()
+        # 根据输出类型返回相应的结果
+        if output == "all":
+            return ax, detections
+        elif "t" in output.lower() and "x" in output.lower():
+            # 提取文本，过滤低置信度的结果
+            text = [text_ for _, text_, score_ in detections if score_ >= thr]
+            if postprocess:
+                return ax, text
+            else:
+                return text_corr
+        elif "score" in output.lower() or "prob" in output.lower():
+            # 提取分数
+            scores = [score_ for _, _, score_ in detections]
+            return ax, scores
+        elif "box" in output.lower():
+            # 提取边界框，过滤低置信度的结果
+            bboxes = [bbox_ for bbox_, _, score_ in detections if score_ >= thr]
+            return ax, bboxes
+        else:
+            # 默认返回所有检测信息
+            return ax, detections
+    else:
+        # 根据输出类型返回相应的结果
+        if output == "all":
+            return detections
+        elif "t" in output.lower() and "x" in output.lower():
+            # 提取文本，过滤低置信度的结果
+            text = [text_ for _, text_, score_ in detections if score_ >= thr]
+            return text
+        elif "score" in output.lower() or "prob" in output.lower():
+            # 提取分数
+            scores = [score_ for _, _, score_ in detections]
+            return scores
+        elif "box" in output.lower():
+            # 提取边界框，过滤低置信度的结果
+            bboxes = [bbox_ for bbox_, _, score_ in detections if score_ >= thr]
+            return bboxes
+        else:
+            # 默认返回所有检测信息
+            return detections
+
+
+def draw_box(
+    image,
+    detections=None,
+    thr=0.25,
+    cmap=cv2.COLOR_BGR2RGB,
+    color_box=(0, 255, 0),  # draw_box
+    color_text=(0, 0, 255),  # draw_box
+    font_scale=0.8,
+    show=True,
+    ax=None,
+    **kwargs,
+):
+
+    if ax is None:
+        ax = plt.gca()
+    if isinstance(image, str):
+        image = cv2.imread(image)
+    if detections is None:
+        detections = get_text(image=image, show=0, output="all", **kwargs)
+
+    for bbox, text, score in detections:
+        if score > thr:
+            top_left = tuple(map(int, bbox[0]))
+            bottom_right = tuple(map(int, bbox[2]))
+            image = cv2.rectangle(image, top_left, bottom_right, color_box, 2)
+            # image = cv2.putText(
+            #     image, text, top_left, font, fontScale, color_text, thickness_text
+            # )
+            image = add_text_pil(
+                image, text, top_left, font_size=font_scale * 32, color=color_text
+            )
+
+    img_cmp = cv2.cvtColor(image, cmap)
+    if show:
+        ax.imshow(img_cmp)
+        ax.axis("off")
+        # plt.show()
+    return img_cmp

py2ls/plot.py

@@ -1637,6 +1637,30 @@ def figsets(*args, **kwargs):
                         ax.tick_params(
                             labelsize=val
                         )  # float, distance in points between tick and label
+        if "text" in key.lower():
+            if isinstance(value, dict):
+                ax.text(**value)
+            elif isinstance(value, list):
+                if all([isinstance(i, dict) for i in value]):
+                    [ax.text(**value_) for value_ in value]
+            # e.g.,
+            # figsets(ax=ax,
+            # text=[
+            #     dict(
+            #         x=1,
+            #         y=1.3,
+            #         s="Wake",
+            #         c="k",
+            #         bbox=dict(facecolor="0.8", edgecolor="none", boxstyle="round,pad=0.1"),
+            #     ),
+            #     dict(
+            #         x=1,
+            #         y=0.4,
+            #         s="Sleep",
+            #         c="k",
+            #         bbox=dict(facecolor="0.8", edgecolor="none", boxstyle="round,pad=0.05"),
+            #     ),
+            # ])
 
         if "mi" in key.lower() and "tic" in key.lower():  # minor_ticks
             if "x" in value.lower() or "x" in key.lower():
@@ -1823,15 +1847,43 @@ def get_color(
         cmap = "grey"
     # Determine color list based on cmap parameter
     if "aut" in cmap:
-        colorlist = [
-            "#474747",
-            "#FF2C00",
-            "#0C5DA5",
-            "#845B97",
-            "#58BBCC",
-            "#FF9500",
-            "#D57DBE",
-        ]
+        if n == 1:
+            colorlist = ["#3A4453"]
+        elif n == 2:
+            colorlist = ["#3A4453", "#DF5932"]
+        elif n == 3:
+            colorlist = ["#3A4453", "#DF5932", "#299D8F"]
+        elif n == 4:
+            # colorlist = ["#3A4453", "#DF5932", "#EBAA00", "#0B4083"]
+            colorlist = ["#81C6BD", "#FBAF63", "#F2675B", "#72A1C9"]
+        elif n == 5:
+            colorlist = [
+                "#3A4453",
+                "#427AB2",
+                "#F09148",
+                "#DBDB8D",
+                "#C59D94",
+                "#AFC7E8",
+            ]
+        elif n == 6:
+            colorlist = [
+                "#3A4453",
+                "#427AB2",
+                "#F09148",
+                "#DBDB8D",
+                "#C59D94",
+                "#E53528",
+            ]
+        else:
+            colorlist = [
+                "#474747",
+                "#FF2C00",
+                "#0C5DA5",
+                "#845B97",
+                "#58BBCC",
+                "#FF9500",
+                "#D57DBE",
+            ]
         by = "start"
     elif any(["cub" in cmap.lower(), "sns" in cmap.lower()]):
         if kwargs:
@@ -1909,6 +1961,10 @@ import matplotlib.pyplot as plt
 
 
 def stdshade(ax=None, *args, **kwargs):
+    """
+    usage:
+    plot.stdshade(data_array, c=clist[1], lw=2, ls="-.", alpha=0.2)
+    """
     # Separate kws_line and kws_fill if necessary
     kws_line = kwargs.pop("kws_line", {})
     kws_fill = kwargs.pop("kws_fill", {})
@@ -1946,8 +2002,9 @@ def stdshade(ax=None, *args, **kwargs):
         ax = plt.gca()
     if ax is None:
         ax = plt.gca()
-    alpha = 0.5
-    acolor = "k"
+    alpha = kwargs.get("alpha", 0.2)
+    acolor = kwargs.get("color", "k")
+    acolor = kwargs.get("c", "k")
     paraStdSem = "sem"
     plotStyle = "-"
     plotMarker = "none"

{py2ls-0.1.9.9.dist-info → py2ls-0.1.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.1.9.9
+Version: 0.1.10.1
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com