Update all metadata and documentation

Author: aiudirog

LICENSE.rst

@@ -2,19 +2,19 @@
 License
 *******
 
-HappyBase itself is licensed under a `MIT License
-<http://www.opensource.org/licenses/MIT>`_. HappyBase contains code originating
-from HBase sources, licensed under the `Apache License
+AIOHappyBase itself is licensed under a `MIT License
+<http://www.opensource.org/licenses/MIT>`_. AIOHappyBase contains code originating from HBase sources, licensed under the `Apache License
 <http://www.apache.org/licenses/>`_ (version 2.0). Both license texts are
 included below.
 
 
-HappyBase License
+AIOHappyBase License
 =================
 
 (This is the `MIT License <http://www.opensource.org/licenses/MIT>`_.)
 
-Copyright © 2012 Wouter Bolsterlee
+Copyright © 2012 Wouter Bolsterlee    // Original HappyBase author
+Copyright © 2019 Roger Aiudi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

MANIFEST.in

@@ -1,5 +1,5 @@
 include Makefile
 include requirements.txt
-include happybase/*.thrift
+include aiohappybase/*.thrift
 include *.rst
 include doc/conf.py doc/*.rst

Makefile

@@ -10,7 +10,8 @@ doc:
 
 test:
 	-find coverage/ -mindepth 1 -delete
-	python $$(which nosetests) $${TESTS}
+	coverage run -m unittest $${TESTS}
+	coverage html
 
 clean:
 	find . -name '*.py[co]' -delete

NEWS.rst

@@ -1,7 +1,22 @@
 Version history
 ===============
 
-.. py:currentmodule:: happybase
+.. py:currentmodule:: aiohappybase
+
+
+AIOHappyBase 1.2.0
+------------------
+
+Release date: 2019-11-??
+
+First release of the async version of HappyBase!
+
+The version number is the same because the API is almost identical (albeit async) except for a few updates:
+
+- Only Python 3.6+ will be supported (I like f-strings and ordered dictionaries, sue me:P)
+- ``Connection`` and ``ConnectionPool`` objects can be used as context managers (async and regular).
+- ``Connection.create_table()`` now returns the table instance.
+- Support for the framed transport and compact protocol have been dropped until thriftpy2.contrib.aio supports them as well.
 
 
 HappyBase 1.2.0

README.rst

@@ -1,12 +1,12 @@
-HappyBase
-=========
+AIOHappyBase
+============
 
-**HappyBase** is a developer-friendly Python_ library to interact with Apache
-HBase_.
+**AIOHappyBase** is a developer-friendly Python_ library to interact asynchronously with Apache
+HBase_. It is a fork of the original [HappyBase](https://github.com/wbolster/happybase) library aiming to deliver a very similar API.
 
-* `Documentation <https://happybase.readthedocs.io/>`_ (Read the Docs)
-* `Downloads <http://pypi.python.org/pypi/happybase/>`_ (PyPI)
-* `Source code <https://github.com/wbolster/happybase>`_ (Github)
+* `Documentation <https://happybase.readthedocs.io/>`_ (Docs) (TODO)
+* `Downloads <http://pypi.python.org/pypi/aiohappybase/>`_ (PyPI) (TODO)
+* `Source code <https://github.com/aiudirog/aiohappybase>`_ (Github)
 
 .. _Python: http://python.org/
 .. _HBase: http://hbase.apache.org/

aiohappybase/pool.py

@@ -97,7 +97,7 @@ async def _acquire_connection(self, timeout: Real = None) -> Connection:
         """Acquire a connection from the pool."""
         try:
             return await aio.wait_for(self._queue.get(), timeout)
-        except aio.futures.TimeoutError:
+        except aio.TimeoutError:
             raise NoConnectionsAvailable("Timeout waiting for a connection")
 
     async def _return_connection(self, connection: Connection) -> None:

doc/api.rst

@@ -2,58 +2,56 @@
 API reference
 =============
 
-.. py:currentmodule:: happybase
+.. py:currentmodule:: aiohappybase
 
-This chapter contains detailed API documentation for HappyBase. It is suggested
-to read the :doc:`user guide <user>` first to get a general idea about how
-HappyBase works.
+This chapter contains detailed API documentation for AIOHappyBase. It is suggested to read the :doc:`user guide <user>` first to get a general idea about how AIOHappyBase works.
 
-The HappyBase API is organised as follows:
+The AIOHappyBase API is organised as follows:
 
-:py:class:`~happybase.Connection`:
-   The :py:class:`~happybase.Connection` class is the main entry point for
+:py:class:`~aiohappybase.Connection`:
+   The :py:class:`~aiohappybase.Connection` class is the main entry point for
    application developers. It connects to the HBase Thrift server and provides
    methods for table management.
 
-:py:class:`~happybase.Table`:
+:py:class:`~aiohappybase.Table`:
    The :py:class:`Table` class is the main class for interacting with data in
    tables. This class offers methods for data retrieval and data manipulation.
    Instances of this class can be obtained using the
    :py:meth:`Connection.table()` method.
 
-:py:class:`~happybase.Batch`:
+:py:class:`~aiohappybase.Batch`:
    The :py:class:`Batch` class implements the batch API for data manipulation,
    and is available through the :py:meth:`Table.batch()` method.
 
-:py:class:`~happybase.ConnectionPool`:
+:py:class:`~aiohappybase.ConnectionPool`:
    The :py:class:`ConnectionPool` class implements a thread-safe connection
    pool that allows an application to (re)use multiple connections.
 
 
 Connection
 ==========
 
-.. autoclass:: happybase.Connection
+.. autoclass:: aiohappybase.Connection
 
 
 Table
 =====
 
-.. autoclass:: happybase.Table
+.. autoclass:: aiohappybase.Table
 
 
 Batch
 =====
 
-.. autoclass:: happybase.Batch
+.. autoclass:: aiohappybase.Batch
 
 
 Connection pool
 ===============
 
-.. autoclass:: happybase.ConnectionPool
+.. autoclass:: aiohappybase.ConnectionPool
 
-.. autoclass:: happybase.NoConnectionsAvailable
+.. autoclass:: aiohappybase.NoConnectionsAvailable
 
 
 .. vim: set spell spelllang=en:

doc/conf.py

@@ -40,8 +40,8 @@
 master_doc = 'index'
 
 # General information about the project.
-project = u'HappyBase'
-copyright = u'2012'
+project = u'AIOHappyBase'
+copyright = u'2019'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -50,7 +50,7 @@
 # The short X.Y version.
 version_file = os.path.join(
     os.path.dirname(__file__),
-    '../happybase/_version.py')
+    '../aiohappybase/_version.py')
 with open(version_file, 'r') as fp:
     exec(fp.read())
 version = __version__

doc/development.rst

@@ -7,13 +7,13 @@ Development
 Getting the source
 ------------------
 
-The HappyBase source code repository is hosted on GitHub:
+The AIOHappyBase source code repository is hosted on GitHub:
 
-   https://github.com/wbolster/happybase
+   https://github.com/aiudirog/aiohappybase
 
 To grab a copy, use this::
 
-   $ git clone https://github.com/wbolster/happybase.git
+   $ git clone https://github.com/aiudirog/aiohappybase.git
 
 
 
@@ -22,35 +22,36 @@ Setting up a development environment
 
 Setting up a development environment from a Git branch is easy::
 
-   $ cd /path/to/happybase/
-   $ mkvirtualenv happybase
-   (happybase)$ pip install -r test-requirements.txt
-   (happybase)$ pip install -e .
+   $ cd /path/to/aiohappybase/
+   $ python -m venv venv
+   $ source venv/bin/activate
+   (venv) $ pip install -r test-requirements.txt
+   (venv) $ pip install -e .
 
 
 Running the tests
 -----------------
 
-The tests use the `nose` test suite. To execute the tests, run::
+The tests use the `asynctest` test suite. To execute the tests, run::
 
-   (happybase)$ make test
+   (venv) $ make test
 
 Test outputs are shown on the console. A test code coverage report is saved in
 `coverage/index.html`.
 
 If the Thrift server is not running on localhost, you can specify these
 environment variables (both are optional) before running the tests::
 
-   (happybase)$ export HAPPYBASE_HOST=host.example.org
-   (happybase)$ export HAPPYBASE_PORT=9091
+   (venv) $ export AIOHAPPYBASE_HOST=host.example.org
+   (venv) $ export AIOHAPPYBASE_PORT=9091
 
 To test the HBase 0.90 compatibility mode, use this::
 
-   (happybase)$ export HAPPYBASE_COMPAT=0.90
+   (venv) $ export AIOHAPPYBASE_COMPAT=0.90
 
-To test the framed Thrift transport mode, use this::
+To test the framed Thrift transport mode (once it is supported), use this::
 
-   (happybase)$ export HAPPYBASE_TRANSPORT=framed
+   (venv) $ export AIOHAPPYBASE_TRANSPORT=framed
 
 Contributing
 ------------

doc/faq.rst

@@ -3,8 +3,12 @@ Frequently asked questions
 ==========================
 
 
-I love HappyBase! Can I donate?
-===============================
+I love AIOHappyBase! Can I donate?
+==================================
+
+While I am not accepting donations at this time, the original author is:
+
+**From the original HappyBase author, Wouter Bolsterlee:**
 
 Thanks, I'm glad to hear that you appreciate my work! If you feel like, please
 make a small donation_ to sponsor my (spare time!) work on HappyBase. Small
@@ -25,39 +29,55 @@ applications using Thrift directly need to deal with many imports, sockets,
 transports, protocols, clients, Thrift types and mutation objects. For instance,
 look at the code required to connect to HBase and store two values::
 
-   from thrift import Thrift
-   from thrift.transport import TSocket, TTransport
-   from thrift.protocol import TBinaryProtocol
+    import asyncio as aio
+
+    from thriftpy2.contrib.aio.client import TAsyncClient
+    from thriftpy2.contrib.aio.socket import TAsyncSocket
+    from thriftpy2.contrib.aio.transport.buffered import TAsyncBufferedTransport
+    from thriftpy2.contrib.aio.protocol.binary import TAsyncBinaryProtocol
+
+    from hbase import Hbase, Mutation
 
-   from hbase import ttypes
-   from hbase.Hbase import Client, Mutation
+    async def main():
 
-   sock = TSocket.TSocket('hostname', 9090)
-   transport = TTransport.TBufferedTransport(sock)
-   protocol = TBinaryProtocol.TBinaryProtocol(transport)
-   client = Client(protocol)
-   transport.open()
+        sock = TAsyncSocket('hostname', 9090)
+        transport = TAsyncBufferedTransport(sock)
+        protocol = TAsyncBinaryProtocol(transport)
+        client = TAsyncClient(Hbase, protocol)
+        transport.open()
+
+        mutations = [
+            Mutation(column=b'family:qual1', value=b'value1'),
+            Mutation(column=b'family:qual2', value=b'value2'),
+        ]
+        await client.mutateRow(b'table-name', b'row-key', mutations)
+
+    aio.run(main())
 
-   mutations = [Mutation(column='family:qual1', value='value1'),
-                Mutation(column='family:qual2', value='value2')]
-   client.mutateRow('table-name', 'row-key', mutations)
 
 :pep:`20` taught us that simple is better than complex, and as you can see,
-Thrift is certainly complex. HappyBase hides all the Thrift cruft below a
+Thrift is certainly complex. AIOHappyBase hides all the Thrift cruft below a
 friendly API. The resulting application code will be cleaner, more productive
-to write, and more maintainable. With HappyBase, the example above can be
+to write, and more maintainable. With AIOHappyBase, the example above can be
 simplified to this::
 
-   import happybase
+    import asyncio as aio
+
+    from aiohappybase import Connection
+
+    async def main():
+        async with Connection('hostname') as conn:
+            table = conn.table(b'table-name')
+            await table.put(b'row-key', {
+                 b'family:qual1': b'value1',
+                 b'family:qual2': b'value2',
+            })
 
-   connection = happybase.Connection('hostname')
-   table = connection.table('table-name')
-   table.put('row-key', {'family:qual1': 'value1',
-                         'family:qual2': 'value2'})
+    aio.run(main())
 
 If you're not convinced and still think the Thrift API is not that bad, please
 try to accomplish some other common tasks, e.g. retrieving rows and scanning
-over a part of a table, and compare that to the HappyBase equivalents. If
-you're still not convinced by then, we're sorry to inform you that HappyBase is
-not the project for you, and we wish you all of luck maintaining your code ‒ or
-is it just Thrift boilerplate?
+over a part of a table, and compare that to the AIOHappyBase equivalents. If
+you're still not convinced by then, we're sorry to inform you that AIOHappyBase
+is not the project for you, and we wish you all of luck maintaining your code
+‒ or is it just Thrift boilerplate?