ARROW-60 Set up auto formatting (#52)

Author: blink1073

bindings/python/addtags.py

@@ -4,8 +4,10 @@
 # Usage:
 # $ python addtags.py WHEEL_PATH TARGET_PLATFORM WHEEL_DIR
 import os
-from os.path import abspath, isfile, exists, basename, join as pjoin
+from os.path import abspath, basename, exists, isfile
+from os.path import join as pjoin
 from sys import argv
+
 from auditwheel.policy import get_priority_by_name, get_replace_platforms
 from auditwheel.wheel_abi import analyze_wheel_abi
 from auditwheel.wheeltools import InWheelCtx, add_platforms
@@ -15,14 +17,13 @@ def repair_wheel(wheel_path, abi, wheel_dir):
     wheel_fname = basename(wheel_path)
     with InWheelCtx(wheel_path) as ctx:
         ctx.out_wheel = pjoin(wheel_dir, wheel_fname)
-        ctx.out_wheel = add_platforms(ctx, [abi],
-                                      get_replace_platforms(abi))
+        ctx.out_wheel = add_platforms(ctx, [abi], get_replace_platforms(abi))
     return ctx.out_wheel
 
 
 def main(wheel_path, abi, wheel_dir):
     if not isfile(wheel_path):
-        raise FileNotFoundError('cannot access wheel file %s' % (wheel_path,))
+        raise FileNotFoundError("cannot access wheel file %s" % (wheel_path,))
 
     if not exists(wheel_dir):
         os.makedirs(wheel_dir)
@@ -33,17 +34,16 @@ def main(wheel_path, abi, wheel_dir):
     if out_wheel is not None:
         analyzed_tag = analyze_wheel_abi(out_wheel).overall_tag
         if reqd_tag < get_priority_by_name(analyzed_tag):
-            print('Wheel is eligible for a higher priority tag. '
-                  'You requested %s but I have found this wheel is '
-                  'eligible for %s.' % (abi, analyzed_tag))
+            print(
+                "Wheel is eligible for a higher priority tag. "
+                "You requested %s but I have found this wheel is "
+                "eligible for %s." % (abi, analyzed_tag)
+            )
             out_wheel = repair_wheel(wheel_path, analyzed_tag, wheel_dir)
 
-        print('Fixed-up wheel written to %s' % (out_wheel,))
+        print("Fixed-up wheel written to %s" % (out_wheel,))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     WHEEL_PATH, TARGET_PLATFORM, WHEEL_DIR = argv[1], argv[2], argv[3]
-    main(
-        wheel_path=abspath(WHEEL_PATH),
-        abi=TARGET_PLATFORM,
-        wheel_dir=abspath(WHEEL_DIR))
+    main(wheel_path=abspath(WHEEL_PATH), abi=TARGET_PLATFORM, wheel_dir=abspath(WHEEL_DIR))

bindings/python/benchmark.py

@@ -8,13 +8,11 @@
 
 import numpy as np
 import pandas as pd
+import pyarrow
 import pymongo
-
 from bson import BSON, CodecOptions, Int64, ObjectId
 from bson.raw_bson import RawBSONDocument
-
-import pyarrow
-from pymongoarrow.api import find_arrow_all, find_numpy_all, Schema, find_pandas_all
+from pymongoarrow.api import Schema, find_arrow_all, find_numpy_all, find_pandas_all
 
 assert pymongo.has_c()
 
@@ -39,45 +37,49 @@ def _setup():
     small = db[collection_names[SMALL]]
     small.drop()
 
-    print("%d small docs, %d bytes each with 3 keys" % (
-        N_SMALL_DOCS,
-        len(BSON.encode({'_id': ObjectId(), 'x': 1, 'y': math.pi}))))
+    print(
+        "%d small docs, %d bytes each with 3 keys"
+        % (N_SMALL_DOCS, len(BSON.encode({"_id": ObjectId(), "x": 1, "y": math.pi})))
+    )
 
-    small.insert_many([
-        collections.OrderedDict([('x', 1), ('y', math.pi)])
-        for _ in range(N_SMALL_DOCS)])
+    small.insert_many(
+        [collections.OrderedDict([("x", 1), ("y", math.pi)]) for _ in range(N_SMALL_DOCS)]
+    )
 
-    dtypes[SMALL] = np.dtype([('x', np.int64), ('y', np.float64)])
-    schemas[SMALL] = Schema({'x': pyarrow.int64(), 'y': pyarrow.float64()})
+    dtypes[SMALL] = np.dtype([("x", np.int64), ("y", np.float64)])
+    schemas[SMALL] = Schema({"x": pyarrow.int64(), "y": pyarrow.float64()})
 
     large = db[collection_names[LARGE]]
     large.drop()
     # 2600 keys: 'a', 'aa', 'aaa', .., 'zz..z'
-    large_doc_keys = [c * i for c in string.ascii_lowercase
-                      for i in range(1, 101)]
+    large_doc_keys = [c * i for c in string.ascii_lowercase for i in range(1, 101)]
     large_doc = collections.OrderedDict([(k, math.pi) for k in large_doc_keys])
-    print("%d large docs, %dk each with %d keys" % (
-        N_LARGE_DOCS, len(BSON.encode(large_doc)) // 1024, len(large_doc_keys)))
+    print(
+        "%d large docs, %dk each with %d keys"
+        % (N_LARGE_DOCS, len(BSON.encode(large_doc)) // 1024, len(large_doc_keys))
+    )
 
     large.insert_many([large_doc.copy() for _ in range(N_LARGE_DOCS)])
 
     dtypes[LARGE] = np.dtype([(k, np.float64) for k in large_doc_keys])
     schemas[LARGE] = Schema({k: pyarrow.float64() for k in large_doc_keys})
 
     # Ignore for now that the first batch defaults to 101 documents.
-    raw_bson_docs_small = [{'x': 1, 'y': math.pi} for _ in range(N_SMALL_DOCS)]
-    raw_bson_small = BSON.encode({'ok': 1,
-                                  'cursor': {
-                                      'id': Int64(1234),
-                                      'ns': 'db.collection',
-                                      'firstBatch': raw_bson_docs_small}})
+    raw_bson_docs_small = [{"x": 1, "y": math.pi} for _ in range(N_SMALL_DOCS)]
+    raw_bson_small = BSON.encode(
+        {
+            "ok": 1,
+            "cursor": {"id": Int64(1234), "ns": "db.collection", "firstBatch": raw_bson_docs_small},
+        }
+    )
 
     raw_bson_docs_large = [large_doc.copy() for _ in range(N_LARGE_DOCS)]
-    raw_bson_large = BSON.encode({'ok': 1,
-                                  'cursor': {
-                                      'id': Int64(1234),
-                                      'ns': 'db.collection',
-                                      'firstBatch': raw_bson_docs_large}})
+    raw_bson_large = BSON.encode(
+        {
+            "ok": 1,
+            "cursor": {"id": Int64(1234), "ns": "db.collection", "firstBatch": raw_bson_docs_large},
+        }
+    )
 
     raw_bsons[SMALL] = raw_bson_small
     raw_bsons[LARGE] = raw_bson_large
@@ -99,62 +101,61 @@ def assign_name(fn):
     return assign_name
 
 
-@bench('conventional-to-ndarray')
+@bench("conventional-to-ndarray")
 def conventional_ndarray(use_large):
     collection = db[collection_names[use_large]]
     cursor = collection.find()
     dtype = dtypes[use_large]
 
     if use_large:
-        np.array([tuple(doc[k] for k in large_doc_keys) for doc in cursor],
-                 dtype=dtype)
+        np.array([tuple(doc[k] for k in large_doc_keys) for doc in cursor], dtype=dtype)
     else:
-        np.array([(doc['x'], doc['y']) for doc in cursor], dtype=dtype)
+        np.array([(doc["x"], doc["y"]) for doc in cursor], dtype=dtype)
 
 
 # Note: this is called "to-numpy" and not "to-ndarray" because find_numpy_all
 # does not produce an ndarray.
-@bench('pymongoarrow-to-numpy')
+@bench("pymongoarrow-to-numpy")
 def to_numpy(use_large):
     c = db[collection_names[use_large]]
     schema = schemas[use_large]
     find_numpy_all(c, {}, schema=schema)
 
 
-@bench('conventional-to-pandas')
+@bench("conventional-to-pandas")
 def conventional_pandas(use_large):
     collection = db[collection_names[use_large]]
     dtype = dtypes[use_large]
-    cursor = collection.find(projection={'_id': 0})
+    cursor = collection.find(projection={"_id": 0})
     data_frame = pd.DataFrame(list(cursor))
 
 
-@bench('pymongoarrow-to-pandas')
+@bench("pymongoarrow-to-pandas")
 def to_pandas(use_large):
     c = db[collection_names[use_large]]
     schema = schemas[use_large]
     find_pandas_all(c, {}, schema=schema)
 
 
-@bench('pymongoarrow-to-arrow')
+@bench("pymongoarrow-to-arrow")
 def to_arrow(use_large):
     c = db[collection_names[use_large]]
     schema = schemas[use_large]
     find_arrow_all(c, {}, schema=schema)
 
 
-parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter,
-                                 epilog="""
+parser = argparse.ArgumentParser(
+    formatter_class=argparse.RawTextHelpFormatter,
+    epilog="""
 Available benchmark functions:
    %s
-""" % ("\n   ".join(bench_fns.keys()),))
-parser.add_argument('--large', action='store_true',
-                    help='only test with large documents')
-parser.add_argument('--small', action='store_true',
-                    help='only test with small documents')
-parser.add_argument('--test', action='store_true',
-                    help='quick test of benchmark.py')
-parser.add_argument('funcs', nargs='*', default=bench_fns.keys())
+"""
+    % ("\n   ".join(bench_fns.keys()),),
+)
+parser.add_argument("--large", action="store_true", help="only test with large documents")
+parser.add_argument("--small", action="store_true", help="only test with small documents")
+parser.add_argument("--test", action="store_true", help="quick test of benchmark.py")
+parser.add_argument("funcs", nargs="*", default=bench_fns.keys())
 options = parser.parse_args()
 
 if options.test:
@@ -175,7 +176,7 @@ def to_arrow(use_large):
 
 for name in options.funcs:
     if name not in bench_fns:
-        sys.stderr.write("Unknown function \"%s\"\n" % name)
+        sys.stderr.write('Unknown function "%s"\n' % name)
         sys.stderr.write("Available functions:\n%s\n" % ("\n".join(bench_fns)))
         sys.exit(1)
 

bindings/python/docs/source/conf.py

@@ -13,36 +13,32 @@
 import os
 import os.path as p
 
-
 # -- Project information -----------------------------------------------------
 
-project = 'PyMongoArrow'
-copyright = 'MongoDB, Inc. 2021-present. MongoDB, Mongo, and the leaf logo are registered trademarks of MongoDB, Inc'
-author = 'Prashant Mital'
+project = "PyMongoArrow"
+copyright = "MongoDB, Inc. 2021-present. MongoDB, Mongo, and the leaf logo are registered trademarks of MongoDB, Inc"
+author = "Prashant Mital"
 html_show_sphinx = False
 
 version_file = p.abspath(p.join("../../", "pymongoarrow/version.py"))
 version_data = {}
-with open(version_file, 'r') as vf:
+with open(version_file, "r") as vf:
     exec(vf.read(), {}, version_data)
-version = version_data['__version__']
+version = version_data["__version__"]
 release = version
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
+pygments_style = "sphinx"
 
 # -- General configuration ---------------------------------------------------
 
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.intersphinx'
-]
+extensions = ["sphinx.ext.autodoc", "sphinx.ext.intersphinx"]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -55,12 +51,9 @@
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'pydoctheme'
+html_theme = "pydoctheme"
 html_theme_path = ["."]
-html_theme_options = {
-    'collapsiblesidebar': True,
-    'googletag': False
-}
+html_theme_options = {"collapsiblesidebar": True, "googletag": False}
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
@@ -71,15 +64,15 @@
 # or fully qualified paths (eg. https://...)
 # Note: html_js_files was added in Sphinx 1.8.
 html_js_files = [
-    'delighted.js',
+    "delighted.js",
 ]
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = 'PyMongoArrow' + release.replace('.', '_')
+htmlhelp_basename = "PyMongoArrow" + release.replace(".", "_")
 
 intersphinx_mapping = {
-    'pyarrow': ('https://arrow.apache.org/docs/', None),
-    'pandas': ('https://pandas.pydata.org/docs/', None),
-    'numpy': ('https://numpy.org/doc/1.20/', None),
-    'pymongo': ('https://pymongo.readthedocs.io/en/stable/', None)
+    "pyarrow": ("https://arrow.apache.org/docs/", None),
+    "pandas": ("https://pandas.pydata.org/docs/", None),
+    "numpy": ("https://numpy.org/doc/1.20/", None),
+    "pymongo": ("https://pymongo.readthedocs.io/en/stable/", None),
 }

bindings/python/pymongoarrow/__init__.py

@@ -11,14 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import os
+
+import warnings
+
 # We must import pyarrow before attempting to load the Cython module.
 import pyarrow
-
-from pymongoarrow.version import __version__, _MIN_LIBBSON_VERSION
-# This line must come second so setuptools can parse the __version__
-# above without having a built application.
-from pymongoarrow.lib import libbson_version
+from pymongoarrow.version import _MIN_LIBBSON_VERSION, __version__
 
 try:
     from pkg_resources import parse_version as _parse_version
@@ -28,10 +26,14 @@
     def _parse_version(version):
         return _LooseVersion(version)
 
-# TODO: PYTHON-2659
-on_rtd = os.environ.get('READTHEDOCS') == 'True'
-if not on_rtd:
+
+try:
+    from pymongoarrow.lib import libbson_version
+
     if _parse_version(libbson_version) < _parse_version(_MIN_LIBBSON_VERSION):
         raise ImportError(
             f"Expected libbson version {_MIN_LIBBSON_VERSION} or greater, "
-            f"found {libbson_version}")
+            f"found {libbson_version}"
+        )
+except ImportError:
+    warnings.warn("This library has not been compiled")