1.3.2

1.Reset the code specification, annotations look clearer now.
2.Improved document semantics for friendlier wording.

README.md

@@ -1,5 +1,5 @@
 [<img alt="LOGO" src="http://www.gqylpy.com/static/img/favicon.ico" height="21" width="21"/>](http://www.gqylpy.com)
-[![Version](https://img.shields.io/pypi/v/gqylpy_cache)](https://pypi.org/project/gqylpy_cache/)
+[![Release](https://img.shields.io/github/release/gqylpy/gqylpy-cache.svg?style=flat-square")](https://github.com/gqylpy/gqylpy-cache/releases/latest)
 [![Python Versions](https://img.shields.io/pypi/pyversions/gqylpy_cache)](https://pypi.org/project/gqylpy_cache)
 [![License](https://img.shields.io/pypi/l/gqylpy_cache)](https://github.com/gqylpy/gqylpy-cache/blob/master/LICENSE)
 [![Downloads](https://pepy.tech/badge/gqylpy_cache/month)](https://pepy.tech/project/gqylpy_cache)
@@ -8,7 +8,7 @@
 
 > 如其名，`gqylpy_cache` 实现缓存功能，由 GQYLPY 团队研发的一个框架，可缓存某个函数或某个类中定义的所有方法的返回值。
 > 
-> > 你一定遇到过这样的情况：你的程序中有一个函数会被多次调用，并且返回值不变。你会怎么做？为提高代码效率，你会先调用一次该函数并把返回值存到一个变量，之后就使用这个变量，而不是重复调用函数。是这样吗？那太Low了。现在，我们传授你一种更高明的方案。使用 `gqylpy_cache` 模块，直接缓存函数返回值。
+> > _你的程序中有一个函数会被多次调用，并且返回值不变，你会怎么做？为提高代码效率，你会先调用一次该函数并把返回值存到一个变量，之后就使用这个变量，而不是重复调用函数。是这样吗？你已经很不错了。但现在，我们要传授你一种比之更简明的方案，使用 `gqylpy_cache` 模块直接缓存函数返回值。_
 > 
 > `gqylpy_cache` 有两种使用方式：当做元类使用，将缓存其元类实例中定义的所有方法的返回值；当做装饰器使用，将缓存被装饰函数的返回值。
 
@@ -22,7 +22,7 @@ import gqylpy_cache
 class Alpha(metaclass=gqylpy_cache):
     ...
 ```
-此时，类 `Alpha` 中定义的所有方法以及`property`属性，在被其实例调用一次后，其返回值都将被缓存，缓存在 `__cache_pool__` 属性中。此后的每次调用，只要参数不变，都是直接从 `__cache_pool__` 中取值，不会重复执行相关代码，大幅减少程序功耗并提高代码可读性。
+此时，类 `Alpha` 中定义的所有方法以及`property`属性，在被其实例调用一次后，返回值都将被缓存，缓存在 `__cache_pool__` 属性中。此后的每次调用，只要参数不变，都是直接从 `__cache_pool__` 中取值，不会重复执行相关代码，大幅减少程序功耗并提高代码可读性。
 
 上述缓存功能默认只作用于单个实例，每个实例都有自己的 `__cache_pool__` 属性，若希望 `Alpha` 的所有实例共享同一份缓存，可启用 `__shared_instance_cache__` 属性：
 ```python
@@ -50,6 +50,13 @@ def alpha():
 ```
 此时，函数 `alpha` 在被调用一次后，其返回值将被缓存。此后的每次调用，只要参数不变，都是直接从缓存中取值，而不会重复执行 `alpha` 函数。
 
+装饰器的用法亦可获得单例类，只要实例化参数一致：
+```python
+@gqylpy_cache
+class Alpha:
+    ...
+```
+
 另外一种兼容编辑器语法提示的用法：
 ```python
 from gqylpy_cache import cache

gqylpy_cache/__init__.py

@@ -27,58 +27,35 @@
 See the License for the specific language governing permissions and
 limitations under the License.
 """
-__version__ = 1, 3, 1
+__version__ = 1, 3, 2
 __author__ = '竹永康 <gqylpy@outlook.com>'
 __source__ = 'https://github.com/gqylpy/gqylpy-cache'
 
-""" Use "gqylpy_cache" as metaclass.
-
-    import gqylpy_cache
-    class Alpha(metaclass=gqylpy_cache):
-        ...
-
-此时，类 "Alpha" 中定义的所有方法以及property属性，在被其实例调用一次后，其返回值都将被缓存，
-缓存在"__cache_pool__" 属性中。此后的每次调用，只要参数不变，都是直接从 "__cache_pool__"
-中取值，不会重复执行相关代码，大幅减少程序功耗并提高代码可读性。
-
-上述缓存功能默认只作用于单个实例，每个实例都有自己的 "__cache_pool__" 属性，若希望 "Alpha" 
-的所有实例共享同一份缓存，可启用 __shared_instance_cache__ 属性：
-
-    class Alpha(metaclass=gqylpy_cache):
-        __shared_instance_cache__ = True
-
-设置类属性 `__shared_instance_cache__ = True` 后，属性 "__cache_pool__" 将被创建在
-"Alpha" 类中，而不是 "Alpha" 的每个实例中。
-
-若希望某个方法或property不被缓存，可将其加入到 "__not_cache__" 列表中：
-
-    class Alpha(metaclass=gqylpy_cache):
-        __not_cache__ = [method_obj_or_method_name, ...]
-
-另外，"Alpha" 的子类也拥有上述缓存功能。
 """
+As the name implies, "gqylpy_cache" implements the cache functionality.
 
-""" Use "gqylpy_cache" as decorator.
+Use "gqylpy_cache" as metaclass.
 
-    import gqylpy_cache
-    @gqylpy_cache
-    def alpha():
-        ...
+    >>> import gqylpy_cache
+    >>> class Alpha(metaclass=gqylpy_cache):
+    >>>     ...
 
-此时，函数 "alpha" 在被调用一次后，其返回值将被缓存。此后的每次调用，只要参数不变，都是直接从
-缓存中取值，而不会重复执行 alpha 函数。
+Use "gqylpy_cache" as decorator.
 
-另外一种兼容编辑器语法提示的用法：
+    >>> import gqylpy_cache
+    >>> @gqylpy_cache
+    >>> def alpha():
+    >>>     ...
 
-    from gqylpy_cache import cache
-    @cache
-    def alpha():
-        ...
+See the documentation at https://github.com/gqylpy/gqylpy-cache.
 """
 
 
 def cache(f):
-    ...
+    """
+    Decorator, cache the return value of the function.
+    To be compatible with the editor syntax hint.
+    """
 
 
 class _xe6_xad_x8c_xe7_x90_xaa_xe6_x80_xa1_xe7_x8e_xb2_xe8_x90_x8d_xe4_xba_x91:
@@ -91,7 +68,9 @@ class _xe6_xad_x8c_xe7_x90_xaa_xe6_x80_xa1_xe7_x8e_xb2_xe8_x90_x8d_xe4_xba_x91:
         if gname[:2] == '__' and gname != '__builtins__':
             setattr(gcode.GqylpyCache, gname, gvalue)
 
-    gcode.GqylpyCache.__module__  = __package__
+    gcode.GqylpyCache.   __module__ = __package__
+    gcode.FunctionCaller.__module__ = __package__
+
     gcode.GqylpyCache.GqylpyCache = gcode.GqylpyCache
     gcode.GqylpyCache.cache       = gcode.FunctionCaller
 

gqylpy_cache/g cache.py

@@ -110,8 +110,9 @@ def check_and_tidy_not_cache(cls, __not_cache__: list, __dict__: dict):
         if not_found:
             x = f'{cls.__module__}.{cls.__name__}'
             e = not_found if len(not_found) > 1 else not_found[0]
-            raise type('NotCacheDefineError', (Exception,), {'__module__': __package__}) \
-                (f'The "{__package__}" instance "{x}" has no method "{e}".')
+            raise type(
+                'NotCacheDefineError', (Exception,), {'__module__': __package__}
+            )(f'"{__package__}" instance "{x}" has no method "{e}".')
 
     @staticmethod
     def delete_repeated(data: list):

setup.py

@@ -1,6 +1,9 @@
 import setuptools
 import gqylpy_cache as g
 
+with open('README.md', encoding='utf8') as f:
+    readme: str = f.read()
+
 setuptools.setup(
     name=g.__name__,
     version='.'.join(str(n) for n in g.__version__),
@@ -9,7 +12,8 @@
     license='Apache 2.0',
     url='http://gqylpy.com',
     project_urls={'Source': g.__source__},
-    long_description=open('README.md', encoding='utf8').read(),
+    description="如其名，它实现缓存功能，可缓存某个函数或某个类中定义的所有方法的返回值。",
+    long_description=readme,
     long_description_content_type='text/markdown',
     packages=[g.__name__],
     python_requires='>=3.6',