simplify README.md

Author: funbringer

README.md

@@ -37,80 +37,34 @@ python my_tests.py
 ```
 
 
-### Logging
-
-By default, `cleanup()` removes all temporary files (DB files, logs etc) that were created by testgres' API methods.
-If you'd like to keep logs, execute `configure_testgres(node_cleanup_full=False)` before running any tests.
-
-> Note: context managers (aka `with`) call `stop()` and `cleanup()` automatically.
-
-testgres supports [python logging](https://docs.python.org/3.6/library/logging.html),
-which means that you can aggregate logs from several nodes into one file:
-
-```python
-import logging
-
-# write everything to /tmp/testgres.log
-logging.basicConfig(filename='/tmp/testgres.log')
-
-# create two different nodes with logging
-node1 = testgres.get_new_node(use_logging=True).init().start()
-node2 = testgres.get_new_node(use_logging=True).init().start()
-
-# execute a few queries
-node1.execute('postgres', 'select 1')
-node2.execute('postgres', 'select 2')
-```
-
-
 ### Examples
 
 Here is an example of what you can do with `testgres`:
 
 ```python
-with testgres.get_new_node('test') as node:
-    node.init()  # run initdb
-    node.start() # start PostgreSQL
-    print(node.execute('postgres', 'select 1'))
-    node.stop()  # stop PostgreSQL
-```
-
-Let's walk through the code. First, you create a new node using:
-
-```python
-with testgres.get_new_node('master') as node:
-```
-
-or
-
-```python
-with testgres.get_new_node('master', '/path/to/DB') as node:
-```
+# create a node with random name, port, etc
+with testgres.get_new_node() as node:
 
-where `master` is a node's application name. Name matters if you're testing something like replication.
-Function `get_new_node()` only creates directory structure in specified directory (or somewhere in '/tmp' if
-we did not specify base directory) for cluster. After that, we have to initialize the PostgreSQL cluster:
+    # run inidb
+    node.init()
 
-```python
-node.init()
-```
+    # start PostgreSQL
+    node.start()
 
-This function runs `initdb` command and adds some basic configuration to `postgresql.conf` and `pg_hba.conf` files.
-Function `init()` accepts optional parameter `allows_streaming` which configures cluster for streaming replication (default is `False`).
-Now we are ready to start:
+    # execute a query in a default DB
+    print(node.execute('select 1'))
 
-```python
-node.start()
+# ... node stops and its files are about to be removed
 ```
 
-Finally, our temporary cluster is able to process queries. There are four ways to run them:
+There are four API methods for runnig queries:
 
 | Command | Description |
 |----------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|
-| `node.psql(dbname, query)` | Runs query via `psql` command and returns tuple `(error code, stdout, stderr)`. |
-| `node.safe_psql(dbname, query)` | Same as `psql()` except that it returns only `stdout`. If an error occures during the execution, an exception will be thrown. |
-| `node.execute(dbname, query)` | Connects to PostgreSQL using `psycopg2` or `pg8000` (depends on which one is installed in your system) and returns two-dimensional array with data. |
-| `node.connect(dbname, username)` | Returns connection wrapper (`NodeConnection`) capable of running several queries within a single transaction. |
+| `node.psql(query, ...)` | Runs query via `psql` command and returns tuple `(error code, stdout, stderr)`. |
+| `node.safe_psql(query, ...)` | Same as `psql()` except that it returns only `stdout`. If an error occures during the execution, an exception will be thrown. |
+| `node.execute(query, ...)` | Connects to PostgreSQL using `psycopg2` or `pg8000` (depends on which one is installed in your system) and returns two-dimensional array with data. |
+| `node.connect(dbname, ...)` | Returns connection wrapper (`NodeConnection`) capable of running several queries within a single transaction. |
 
 The last one is the most powerful: you can use `begin(isolation_level)`, `commit()` and `rollback()`:
 ```python
@@ -120,10 +74,30 @@ with node.connect() as con:
     con.rollback()
 ```
 
-To stop the server, run:
+
+### Logging
+
+By default, `cleanup()` removes all temporary files (DB files, logs etc) that were created by testgres' API methods.
+If you'd like to keep logs, execute `configure_testgres(node_cleanup_full=False)` before running any tests.
+
+> Note: context managers (aka `with`) call `stop()` and `cleanup()` automatically.
+
+testgres supports [python logging](https://docs.python.org/3.6/library/logging.html),
+which means that you can aggregate logs from several nodes into one file:
 
 ```python
-node.stop()
+import logging
+
+# write everything to /tmp/testgres.log
+logging.basicConfig(filename='/tmp/testgres.log')
+
+# create two different nodes with logging
+node1 = testgres.get_new_node(use_logging=True).init().start()
+node2 = testgres.get_new_node(use_logging=True).init().start()
+
+# execute a few queries
+node1.execute('select 1')
+node2.execute('select 2')
 ```
 
 
@@ -134,7 +108,10 @@ It's quite easy to create a backup and start a new replica:
 ```python
 with testgres.get_new_node('master') as master:
     master.init().start()
+
+    # create a backup
     with master.backup() as backup:
+
         # create and start a new replica
         replica = backup.spawn_replica('replica').start()
 
@@ -147,7 +124,7 @@ with testgres.get_new_node('master') as master:
 
 ### Benchmarks
 
-`testgres` also can help you to make benchmarks using `pgbench` from postgres installation:
+`testgres` is also capable of running benchmarks using `pgbench`:
 
 ```python
 with testgres.get_new_node('master') as master: