Lint

Author: rocky

xdis/marsh.py

@@ -139,7 +139,7 @@ def w_long(self, x):
         self._write(a + b + c + d)
 
     def w_short(self, x):
-        self._write(chr((x) & 0xFF))
+        self._write(chr(x & 0xFF))
         self._write(chr((x >> 8) & 0xFF))
 
     def dump_none(self, x):

xdis/std.py

@@ -16,13 +16,14 @@
 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 """
-Provide the same API as Python 3.x so xdis can be used as a drop in
-replacement for dis. This will provide a dis module with support for the
-Python version being run.
+Provide the same API as Python 3.x so xdis can be used as a drop-in
+replacement for ``dis``.
+
+This will provide ``dis`` module with support for the Python version being run.
 
 Why would you want this? The main reason is if you want a compatibility shim
-for supporting the more advanced Python 3 dis API (being able to iterate through
-opcodes, supplying a custom file to dump the dis to) across python versions, for
+for supporting the more advanced Python3 dis API. That is, to be able to iterate through
+opcodes, supplying a custom file to dump the dis to across python versions. For
 example:
 
     import xdis.std as dis
@@ -31,7 +32,7 @@
     for op in dis.Bytecode('for i in range(10): pass'):
         print(op)
 
-There is also the ability to generate a std api for a specific version, for example:
+There is also the ability to generate a std api for a specific version. For example:
 
     from xdis.std import make_std_api
     dis = make_std_api(2.4)
@@ -88,12 +89,12 @@ def __init__(self, python_version=sys.version_info, variant=VARIANT):
         self.HAVE_ARGUMENT = opc.HAVE_ARGUMENT
 
         class Bytecode(_Bytecode):
-            """The bytecode operations of a piece of code
+            """The bytecode operations in a piece of code
 
             Instantiate this with a function, method, string of code, or a code object
             (as returned by compile()).
 
-            Iterating over this yields a bytecode operation as Instruction instances.
+            Iterating over these yields a bytecode operation as Instruction instances.
             """
 
             def __init__(self, x, first_line=None, current_offset=None, opc=None):
@@ -248,26 +249,27 @@ def findlabels(self, code):
         """Detect all offsets in a byte code which are jump targets.
 
         Return the list of offsets.
-
         """
         return self.opc.findlabels(code, self.opc)
 
 
 def make_std_api(python_version=sys.version_info, variant=VARIANT):
     """
-    Generate an object which can be used in the same way as the python
-    standard dis module. The difference is that the generated 'module' can be
+    Generate an object which can be used in the same way as the Python
+    standard ``dis`` module.
+
+    The difference is that the generated 'module' can be
     used to disassemble byte / word code from a different python version than
     the version of the interpreter under which we are running.
 
     :param python_version: Generate a dis module for this version of python
                            (defaults to the currently running python version.)
     :param variant:        The string denoting the variant of the python version
-                           being run, for example 'pypy' or 'alpha0', 'rc1' etc,,
-                           or None to auto detect based on the currently running
+                           being run, for example 'pypy' or 'alpha0', 'rc1' etc.,
+                           or None to auto-detect based on the currently running
                            interpreter.
 
-    :return: object which can be used like the std dis module.
+    :return: An Object which can be used like the std ``dis`` module.
     """
     if isinstance(python_version, float):
         major = int(python_version)

xdis/unmarshal.py

@@ -22,8 +22,8 @@
 a different version than the currently-running Python.
 
 When the running interpreter and the read-in bytecode are the same,
-you can simply use Python's built-in marshal.loads() to produce a code
-object
+you can use Python's built-in ``marshal.loads()`` to produce a code
+object.
 """
 
 import io
@@ -54,14 +54,14 @@ def long(n):
 FLAG_REF = 0x80
 
 
-# The keys in following dictionary are an unmashal codes, like "s",
-# "c", "<", etc.  the values of the dictionary are names of routines
+# The keys in the following dictionary are unmarshal codes, like "s",
+# "c", "<", etc. The values of the dictionary are names of routines
 # to call that do the data unmarshaling.
 #
-# Note: we could eliminate the parameters, if this were all inside a
+# Note: we could eliminate the parameters if this were all inside a
 # class.  This might be good from an efficiency standpoint, and bad
 # from a functional-programming standpoint. Pick your poison.
-# EDIT: I'm choosing efficiency over functional-programming.
+# EDIT: I'm choosing efficiency over functional programming.
 UNMARSHAL_DISPATCH_TABLE = {
     "0": "C_NULL",
     "N": "None",
@@ -116,10 +116,10 @@ def compat_str(s: Union[str, bytes]) -> Union[str, bytes]:
 
 def compat_u2s(u):
     if PYTHON_VERSION_TRIPLE < (3, 0):
-        # See also unaccent.py which can be found using google. I
+        # See also ``unaccent.py`` which can be found using Google. I
         # found it and this code via
         # https://www.peterbe.com/plog/unicode-to-ascii where it is a
-        # dead link. That can potentially do better job in converting accents.
+        # dead link. That can potentially do a better job in converting accents.
         s = unicodedata.normalize("NFKD", u)
         try:
             return s.encode("ascii")
@@ -139,7 +139,7 @@ def __init__(self, fp, magic_int, bytes_for_s, code_objects={}):
             3: [3.4a0, 3.4a3) (self.magic_int: 3250 until 3280)
             4: [3.4a3, current) (self.magic_int: 3280 onwards)
 
-        In Python 3 a bytes type is used for strings.
+        In Python 3, a ``bytes`` type is used for strings.
         """
         self.fp = fp
         self.magic_int = magic_int
@@ -167,7 +167,7 @@ def __init__(self, fp, magic_int, bytes_for_s, code_objects={}):
 
     def load(self):
         """
-        marshal.load() written in Python. When the Python bytecode magic loaded is the
+        ``marshal.load()`` written in Python. When the Python bytecode magic loaded is the
         same magic for the running Python interpreter, we can simply use the
         Python-supplied marshal.load().
 
@@ -316,8 +316,8 @@ def t_binary_complex(self, save_ref, bytes_for_s=False):
     # Note: could mean bytes in Python3 processing Python2 bytecode
     def t_string(self, save_ref, bytes_for_s: bool):
         """
-        In Python3 this is a bytes types. In Python2 it is a string.
-        `bytes_for_s` distinguishes what we need.
+        In Python3, this is a ``bytes`` type.  In Python2, it is a string type;
+        ``bytes_for_s`` distinguishes what we need.
         """
         strsize = unpack("<i", self.fp.read(4))[0]
         s = self.fp.read(strsize)

xdis/util.py

@@ -1,4 +1,4 @@
-# Much of this is borrowed from Python's Lib/dis.py
+# Much of this is borrowed from Python's ``Lib/dis.py``.
 
 from math import copysign
 from typing import Dict
@@ -57,7 +57,7 @@ def num2code(num):
     (v, k) for (k, v) in COMPILER_FLAG_NAMES.items()
 )
 
-# Allow us to access by just name, prefixed with CO., e.g
+# Allow us to access by just name, prefixed with CO., e.g.,
 # CO_OPTIMIZED, CO_NOFREE.
 globals().update(dict(("CO_" + k, v) for (k, v) in COMPILER_FLAG_BIT.items()))
 

xdis/verify.py

@@ -41,9 +41,9 @@ def dump_compile(codeobject, filename, timestamp, magic):
     """Write ``codeobject`` as a byte-compiled file.
 
     Arguments:
-    codeobject: code object
-    filename: bytecode file to write
-    timestamp: timestamp to put in file
+    codeobject: Code object
+    filename:  ytecode file to write
+    timestamp: Tme stamp to put in file
     magic: Python bytecode magic
     """
     # Atomically write the pyc/pyo file.  Issue #13146.