2016-03-02 00:01:28,147: DEBUG   : bind: address=('localhost', 33981)
2016-03-02 00:01:28,148: DEBUG   : listen: backlog=5
2016-03-02 00:01:28,148: INFO    : Anaconda Server started in port 33981 for PID 24216 with cache dir /home/thevaliantx/.cache/jedi/anaconda-2
2016-03-02 00:01:28,158: INFO    : Incomming connection from ('127.0.0.1', 35405)
2016-03-02 00:01:28,158: INFO    : Incomming connection from ('127.0.0.1', 35406)
2016-03-02 00:01:28,168: INFO    : client requests: lint
2016-03-02 00:01:28,171: INFO    : About push back to ST3: {"vid": 17, "errors": [{"level": "V", "raw_error": "[V] PEP 8 (W292): no newline at end of file", "lineno": 2, "offset": 1, "message": "[v] pep 8 (%s): %s", "underline_range": true}, {"regex": "((and|or|not|if|elif|while|in)\\s+|[+\\-*^%%<>=\\(\\{])*\\s*(?P<underline>[\\w\\.]*b[\\w]*)", "level": "W", "raw_error": "undefined name 'b'", "len": 1, "lineno": 2, "offset": 0, "message": "Undefined name %r", "underline_range": false}], "uid": "3e71b991fcdc49358ab4145ba7bffc67", "success": true}

2016-03-02 00:01:28,171: INFO    : client requests: doc
2016-03-02 00:01:29,672: INFO    : About push back to ST3: {"doc": "", "uid": "b3300e298f794bdf948ed5abd2452873", "success": false}

2016-03-02 00:01:29,672: INFO    : client requests: doc
2016-03-02 00:01:29,675: INFO    : About push back to ST3: {"doc": "", "uid": "af14194de207415c89039a2a1b8aa0ef", "success": false}

2016-03-02 00:01:29,675: INFO    : client requests: doc
2016-03-02 00:01:29,677: INFO    : About push back to ST3: {"doc": "", "uid": "2d4082ec699440caa8c55d4a24ff0298", "success": false}

2016-03-02 00:01:29,677: INFO    : client requests: doc
2016-03-02 00:01:29,679: INFO    : About push back to ST3: {"doc": "", "uid": "20caa586603840e99063e8635d945c0b", "success": false}

2016-03-02 00:01:29,679: INFO    : client requests: doc
2016-03-02 00:01:29,680: INFO    : About push back to ST3: {"doc": "", "uid": "6397604379b842ac89f18f5a3376e15b", "success": false}

2016-03-02 00:01:29,685: INFO    : client requests: doc
2016-03-02 00:01:29,687: INFO    : About push back to ST3: {"doc": "None\n", "uid": "f497ebf6e7c64acd83c772600dc42dcc", "success": true}

2016-03-02 00:01:30,468: INFO    : client requests: doc
2016-03-02 00:01:30,471: INFO    : About push back to ST3: {"doc": "", "uid": "b82546dc528247fdb6a524ea9036510b", "success": false}

2016-03-02 00:01:31,437: INFO    : client requests: doc
2016-03-02 00:01:31,441: INFO    : About push back to ST3: {"doc": "None\n", "uid": "67920556586a44b584f5589887389987", "success": true}

2016-03-02 00:01:35,472: INFO    : client requests: doc
2016-03-02 00:01:35,475: INFO    : About push back to ST3: {"doc": "None\n", "uid": "fd745aec090b4979adcdae4056c9b945", "success": true}

2016-03-02 00:01:35,842: INFO    : client requests: doc
2016-03-02 00:01:35,849: INFO    : About push back to ST3: {"doc": "None\n<br>Mutable Sequence Types<br>**********************<br><br>List and ``bytearray`` objects support additional operations that<br>allow in-place modification of the object. Other mutable sequence<br>types (when added to the language) should also support these<br>operations. Strings and tuples are immutable sequence types: such<br>objects cannot be modified once created. The following operations are<br>defined on mutable sequence types (where *x* is an arbitrary object):<br><br>+--------------------------------+----------------------------------+-----------------------+<br>| Operation                      | Result                           | Notes                 |<br>+================================+==================================+=======================+<br>| ``s[i] = x``                   | item *i* of *s* is replaced by   |                       |<br>|                                | *x*                              |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s[i:j] = t``                 | slice of *s* from *i* to *j* is  |                       |<br>|                                | replaced by the contents of the  |                       |<br>|                                | iterable *t*                     |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``del s[i:j]``                 | same as ``s[i:j] = []``          |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s[i:j:k] = t``               | the elements of ``s[i:j:k]`` are | (1)                   |<br>|                                | replaced by those of *t*         |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``del s[i:j:k]``               | removes the elements of          |                       |<br>|                                | ``s[i:j:k]`` from the list       |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.append(x)``                | same as ``s[len(s):len(s)] =     | (2)                   |<br>|                                | [x]``                            |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.extend(x)``                | same as ``s[len(s):len(s)] = x`` | (3)                   |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.count(x)``                 | return number of *i*'s for which |                       |<br>|                                | ``s[i] == x``                    |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.index(x[, i[, j]])``       | return smallest *k* such that    | (4)                   |<br>|                                | ``s[k] == x`` and ``i <= k < j`` |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.insert(i, x)``             | same as ``s[i:i] = [x]``         | (5)                   |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.pop([i])``                 | same as ``x = s[i]; del s[i];    | (6)                   |<br>|                                | return x``                       |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.remove(x)``                | same as ``del s[s.index(x)]``    | (4)                   |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.reverse()``                | reverses the items of *s* in     | (7)                   |<br>|                                | place                            |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br>| ``s.sort([cmp[, key[,          | sort the items of *s* in place   | (7)(8)(9)(10)         |<br>| reverse]]])``                  |                                  |                       |<br>+--------------------------------+----------------------------------+-----------------------+<br><br>Notes:<br><br>1. *t* must have the same length as the slice it is  replacing.<br><br>2. The C implementation of Python has historically accepted multiple<br>   parameters and implicitly joined them into a tuple; this no longer<br>   works in Python 2.0.  Use of this misfeature has been deprecated<br>   since Python 1.4.<br><br>3. *x* can be any iterable object.<br><br>4. Raises ``ValueError`` when *x* is not found in *s*. When a negative<br>   index is passed as the second or third parameter to the ``index()``<br>   method, the list length is added, as for slice indices.  If it is<br>   still negative, it is truncated to zero, as for slice indices.<br><br>   Changed in version 2.3: Previously, ``index()`` didn't have<br>   arguments for specifying start and stop positions.<br><br>5. When a negative index is passed as the first parameter to the<br>   ``insert()`` method, the list length is added, as for slice<br>   indices.  If it is still negative, it is truncated to zero, as for<br>   slice indices.<br><br>   Changed in version 2.3: Previously, all negative indices were<br>   truncated to zero.<br><br>6. The ``pop()`` method's optional argument *i* defaults to ``-1``, so<br>   that by default the last item is removed and returned.<br><br>7. The ``sort()`` and ``reverse()`` methods modify the list in place<br>   for economy of space when sorting or reversing a large list.  To<br>   remind you that they operate by side effect, they don't return the<br>   sorted or reversed list.<br><br>8. The ``sort()`` method takes optional arguments for controlling the<br>   comparisons.<br><br>   *cmp* specifies a custom comparison function of two arguments (list<br>   items) which should return a negative, zero or positive number<br>   depending on whether the first argument is considered smaller than,<br>   equal to, or larger than the second argument: ``cmp=lambda x,y:<br>   cmp(x.lower(), y.lower())``.  The default value is ``None``.<br><br>   *key* specifies a function of one argument that is used to extract<br>   a comparison key from each list element: ``key=str.lower``.  The<br>   default value is ``None``.<br><br>   *reverse* is a boolean value.  If set to ``True``, then the list<br>   elements are sorted as if each comparison were reversed.<br><br>   In general, the *key* and *reverse* conversion processes are much<br>   faster than specifying an equivalent *cmp* function.  This is<br>   because *cmp* is called multiple times for each list element while<br>   *key* and *reverse* touch each element only once.  Use<br>   ``functools.cmp_to_key()`` to convert an old-style *cmp* function<br>   to a *key* function.<br><br>   Changed in version 2.3: Support for ``None`` as an equivalent to<br>   omitting *cmp* was added.<br><br>   Changed in version 2.4: Support for *key* and *reverse* was added.<br><br>9. Starting with Python 2.3, the ``sort()`` method is guaranteed to be<br>   stable.  A sort is stable if it guarantees not to change the<br>   relative order of elements that compare equal --- this is helpful<br>   for sorting in multiple passes (for example, sort by department,<br>   then by salary grade).<br><br>10. **CPython implementation detail:** While a list is being sorted,<br>    the effect of attempting to mutate, or even inspect, the list is<br>    undefined.  The C implementation of Python 2.3 and newer makes the<br>    list appear empty for the duration, and raises ``ValueError`` if<br>    it can detect that the list has been mutated during a sort.<br>", "uid": "9bb110ed6ab14024bc7ed4fbad3ceb7b", "success": true}

2016-03-02 00:01:38,075: INFO    : client requests: doc
2016-03-02 00:01:38,078: INFO    : About push back to ST3: {"doc": "None\n", "uid": "434cd9e01ea24c8fa7d735093eb1caff", "success": true}

2016-03-02 00:01:41,187: INFO    : process 24216 does not exists stopping server...
2016-03-02 00:01:42,189: INFO    : Closing the socket, server will be shutdown now...