diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 7569be5b0..eaa17b244 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,7 +1,7 @@
 <!--
 Thank you for contributing to keyvi!
 
-Before submission, please ensure that you have read and agree to our 
+Before submission, please ensure that you have read and agree to our
 contributor guidelines: https://github.com/KeyviDev/keyvi/blob/master/CONTRIBUTING.md.
 
 Please delete these lines.
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 5407721e6..06c87ea99 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -28,7 +28,9 @@ repos:
       - id: check-toml
       - id: check-yaml
       - id: end-of-file-fixer
+        exclude: '^(.*\.svg)$'
       - id: trailing-whitespace
+        exclude: '^(.*\.svg)$'
   - repo: https://github.com/charliermarsh/ruff-pre-commit
     rev: "v0.14.0"
     hooks:
diff --git a/LICENSE b/LICENSE
index 8f71f43fe..8dada3eda 100644
--- a/LICENSE
+++ b/LICENSE
@@ -199,4 +199,3 @@
    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.
-
diff --git a/doc/RELEASE_PROCESS.md b/doc/RELEASE_PROCESS.md
index 30c519837..7bf77442f 100644
--- a/doc/RELEASE_PROCESS.md
+++ b/doc/RELEASE_PROCESS.md
@@ -10,7 +10,7 @@ Create a release branch called `release-X.Y.Z`
  - Commit to `release-X.Y.Z` and push it to https://github.com/KeyviDev/keyvi/
  - Wait for CI to build all targets
 
-### Create tag 
+### Create tag
  - Draft a new release tagged vX.Y.Z with `release-X.Y.Z` as the target branch
  - Add the release notes in the description with references to PRs
  - Publish release
@@ -18,7 +18,7 @@ Create a release branch called `release-X.Y.Z`
 ## On the `master` branch
 
 ### Update the `python/setup.py` file
- - Update to the next release version 
+ - Update to the next release version
 ```
 VERSION_MAJOR = X
 VERSION_MINOR = Y
diff --git a/doc/algorithm/Construction-Basics.md b/doc/algorithm/Construction-Basics.md
index a376c48d9..8f09a1b02 100644
--- a/doc/algorithm/Construction-Basics.md
+++ b/doc/algorithm/Construction-Basics.md
@@ -1,6 +1,6 @@
 ## Introduction
 
-“An automaton (plural: automata) is a self-operating machine. The word is sometimes used to describe a robot, more 
+“An automaton (plural: automata) is a self-operating machine. The word is sometimes used to describe a robot, more
 specifically an autonomous robot. Used colloquially, it refers to a mindless follower.”  (Wikipedia)
 
 ### Minimal Acyclic Finite State Automata
@@ -19,7 +19,7 @@ Minimizing yields the FSA:
 keyvi is using so called "incremental construction", the alternative are obviously non-incremental algorithms. If you are curious, there are
 some instruction classes available on youtube.
 
-keyvi is only about text/string automata. There are other use cases for finite state techniques, e.g. modeling 
+keyvi is only about text/string automata. There are other use cases for finite state techniques, e.g. modeling
 real control flows.
 
 ### Incremental Construction by Watson/Daciuk
@@ -34,7 +34,7 @@ real control flows.
             replace_or_register(LastState)‏
         add_suffix(LastState, CurrentSuffix)‏
     replace_or_register(q0)‏
-    
+
     func replace_or_register(State):
         Child = last_child(State)‏
         if (has_children (Child):
@@ -42,11 +42,11 @@ real control flows.
         if Register.find(Child):
             last_child = Register[Child]
         else:
-            Register.add(Child)	
-	
+            Register.add(Child)
+
 ![Construction example Daciuk/Watson](/doc/images/daciuk_watson.png)
 
-### Incremental Construction in Keyvi 
+### Incremental Construction in Keyvi
 
 #### Algorithm
 
@@ -55,17 +55,17 @@ real control flows.
     while (another word):
         new_word = next word in lexicographic order
         common_prefix = common_prefix(current_word, new_word)‏
-        feed_stack ( current_word , length( common_prefix), length ( current_word ) )			
+        feed_stack ( current_word , length( common_prefix), length ( current_word ) )
         consume_stack ( length ( common_prefix ) )‏
         current_word = new_word
     feed_stack ( current_word, 0, length ( current_word ) )‏
     consume_stack ( 0 )‏
-    
+
     func feed_stack( word, begin, end ):
         for ( i = begin, i<end, ++i ):
             unpacked_state_stack.insert(i, word[i])‏
         unpacked_state_stack.insert(end, “final”)‏
-    
+
     func consume_stack(end):
         while ( highest_stack > end ):
             stack_entry = unpacked_state_stack.pop(highest_stack)‏
@@ -75,9 +75,9 @@ real control flows.
 
 Code:
  General entry point: [generator](/keyvi/src/cpp/dictionary/fsa/generator.h)
- 
+
  Unpacked_State_Stack: [unpacked_state_stack](/keyvi/src/cpp/dictionary/fsa/internal/unpacked_state_stack.h)
- 
+
 #### Illustration
 
 Building a tiny automata containing just 4 strings:
@@ -88,47 +88,47 @@ Building a tiny automata containing just 4 strings:
     abe
 
 ## Step1
-  
-  
+
+
 ![Step1](/doc/images/construction_step1.png)
-  
-  
+
+
 ## Step2
-  
-  
+
+
 ![Step2](/doc/images/construction_step2.png)
-  
-  
+
+
 ## Step3
-  
-  
+
+
 ![Step3](/doc/images/construction_step3.png)
-  
-  
+
+
 ## Step4
-  
-  
+
+
 ![Step4](/doc/images/construction_step4.png)
-  
-  
+
+
 ##Step5
-  
-  
+
+
 ![Step5](/doc/images/construction_step5.png)
-  
-  
+
+
 ## Step6
-  
-  
+
+
 ![Step6](/doc/images/construction_step6.png)
-  
-  
+
+
 ## Step7
-  
-  
+
+
 ![Step7](/doc/images/construction_step7.png)
-  
-  
+
+
 #### Summary
 
 The FSA is built from "right to left", the root state is written last.
@@ -138,4 +138,3 @@ The FSA is built from "right to left", the root state is written last.
  - use sorted data characteristic: compare only the last two words
  - no temporary state creation as with replace_or_register, which can be problematic depended on underlying data structure (e.g. Sparse Array)‏
  - no recursion (as in replace_or_register)‏
-
diff --git a/doc/algorithm/Extensibility.md b/doc/algorithm/Extensibility.md
index ac2da9f75..bfb9c4544 100644
--- a/doc/algorithm/Extensibility.md
+++ b/doc/algorithm/Extensibility.md
@@ -1,20 +1,20 @@
 ## Extensibility
 
-The keyvi compiler is implemented in C++11 and uses templates to allow customization, like having a different 
+The keyvi compiler is implemented in C++11 and uses templates to allow customization, like having a different
 persistence layer, different minimization, etc.
 
 The most useful customization are different value types:
 
 ### Value types
 
-Keys are always strings, values can be of any type, even nested types. Built-in types at time of writing are no-value, 
+Keys are always strings, values can be of any type, even nested types. Built-in types at time of writing are no-value,
 integer, strings and json.
 
 Value types have to implement a ["duck-type"](http://en.wikipedia.org/wiki/Duck_typing) interface.
 
 Code: [IValue_Store](/keyvi/src/cpp/dictionary/fsa/internal/ivalue_store.h)
 
-In a nutshell, writing a new value store entails: serialization of the value, the interface to the compiler and the 
+In a nutshell, writing a new value store entails: serialization of the value, the interface to the compiler and the
 deserialization for the lookup.
 
 Note: The compiler interface expects an ID for each unique value, the ID is used for minimization.
diff --git a/doc/algorithm/Minimization.md b/doc/algorithm/Minimization.md
index 6ff908c6e..a2bb94b26 100644
--- a/doc/algorithm/Minimization.md
+++ b/doc/algorithm/Minimization.md
@@ -5,10 +5,10 @@ new state.
 
 ### keyvi Minimization
 
-Minimization is implemented using a hash table. Each state that is written, is inserted into the hash table. Before 
+Minimization is implemented using a hash table. Each state that is written, is inserted into the hash table. Before
 persisting a new state, we try to find a equal state in the hashtable.
 
-Code: 
+Code:
 
 Entry point of minimization: [sparse_array_builder](/keyvi/src/cpp/dictionary/fsa/internal/sparse_array_builder.h)
 Minimization Hashtable: [sparse_array_builder](/keyvi/src/cpp/dictionary/fsa/internal/minimization_hash.h)
@@ -17,7 +17,7 @@ The Hashtable in keyvi has a very small footprint of 12 bytes per entry.
 
 ## Getting best Compression ratios
 
-Minimization/Compression is dependent on the data. FSA's are mainly used in computational linguistics, one of the reasons: 
+Minimization/Compression is dependent on the data. FSA's are mainly used in computational linguistics, one of the reasons:
 FSA's make use of high ambiguity in languages.
 
 ![Compression](/doc/images/compression.png)
@@ -27,11 +27,11 @@ FSA's make use of high ambiguity in languages.
 Therefore having "natural language keys" yields compression, both at prefix as well as suffix side. "Binary keys", e.g.
 fingerprints, are pretty bad in terms of compression.
 
-Note that Prefix compression is basically the same as in a trie. 
+Note that Prefix compression is basically the same as in a trie.
 
 ### Suffix and Value Compression
 
-In contrast to a trie the FSA compresses suffixes as well. But note: The value is part of the suffix, as it is attached 
+In contrast to a trie the FSA compresses suffixes as well. But note: The value is part of the suffix, as it is attached
 to the "final state". Therefore sparse values will yield best results while having totally unique values will result in
 no suffix compression.
 
@@ -39,16 +39,16 @@ no suffix compression.
 
 Normalize keys to gain better prefix compression.
 
-Think about your values, reduce the version space if possible. For example: if you store integer values, think about their 
+Think about your values, reduce the version space if possible. For example: if you store integer values, think about their
 range. Normalizing the integers reduce the number of unique values and therefore improve the compression ratio.
 
 Take minimization into account: permutations and repetitions are a strength of the algorithm, e.g. storing tons of almost
  identical keys pointing to the same value. In other data structures this can cause huge memory usage, FSA's are good in
  minimizing that.
- 
+
 ### Check Questions
 
-1. You want to write a Date Extractor which can extract all dates of the fomat "YYYY-MM-DD". Estimate the size 
-requirement. 
+1. You want to write a Date Extractor which can extract all dates of the fomat "YYYY-MM-DD". Estimate the size
+requirement.
 
-2. Now assign a counter(incremented each time) to each key. What happens? What about your size estimate? 
+2. Now assign a counter(incremented each time) to each key. What happens? What about your size estimate?
diff --git a/doc/algorithm/Persistence-Basics.md b/doc/algorithm/Persistence-Basics.md
index ee4229866..c5fdff732 100644
--- a/doc/algorithm/Persistence-Basics.md
+++ b/doc/algorithm/Persistence-Basics.md
@@ -1,23 +1,23 @@
 ## Persistence Introduction
 
-The default persistence is implemented as sparse array (sparse table). 
+The default persistence is implemented as sparse array (sparse table).
 
 Code: [sparse_array_persistence](/keyvi/src/cpp/dictionary/fsa/internal/sparse_array_persistence.h)
 
 ### Sparse Array in a nutshell
 
-The underlying data structure consists of 2 simple arrays of the same length(not size), a byte array and a 
+The underlying data structure consists of 2 simple arrays of the same length(not size), a byte array and a
 pointer array(e.g. uint32_t)
 
 ![SparseArraySingleState](/doc/images/sparse_array_single_state.png)
 
-A lookup starts at a given offset, a lookup succeeds if the numeric value (e.g. ASCII value) is found in the bucket 
+A lookup starts at a given offset, a lookup succeeds if the numeric value (e.g. ASCII value) is found in the bucket
 defined by sum of the offset and the numeric value.
 
 ![SparseArrayPointer](/doc/images/sparse_array_pointer.png)
 
 This check is required to allow interleaving of state vectors. To save space vectors of states are interleaved:
- 
+
 ![SparseArrayInterleaved](/doc/images/sparse_array_mixed.png)
 
 Even with a brute-force method that interleaves state vectors yields a very good compression rate.
@@ -30,4 +30,3 @@ The algorithm tries to find space in the existing sparse array:
 ![SparseArrayPacking](/doc/images/sparse_array_packing.png)
 
 Code: [sparse_array_building](/keyvi/src/cpp/dictionary/fsa/internal/sparse_array_builder.h)
-
diff --git a/doc/algorithm/Scaling.md b/doc/algorithm/Scaling.md
index ca2251640..1d4891124 100644
--- a/doc/algorithm/Scaling.md
+++ b/doc/algorithm/Scaling.md
@@ -5,7 +5,7 @@ This page describes a number of performance and scaling tricks to make it possib
 ### Sorting
 
 The construction algorithm requires sorted input. To be able to create a dictionary out of millions of keys we apply
-  external memory sorting. Fortunately "sorting" huge lists is not a problem these days. keyvi uses 
+  external memory sorting. Fortunately "sorting" huge lists is not a problem these days. keyvi uses
   [TPIE](http://madalgo.au.dk/tpie/) for external merge sort.
 
 Note: Map-Reduce also sorts data using external memory sort, so using Map-Reduce with 1 Reducer would also give you
@@ -18,27 +18,27 @@ Code: [dictionary_compiler](/keyvi/src/cpp/dictionary/dictionary_compiler.h)
 
 ### Minimization
 
-For each state the compiler stores a fingerprint of the state in the hashtable, although a fingerprint is stored in 
+For each state the compiler stores a fingerprint of the state in the hashtable, although a fingerprint is stored in
 12 bytes the hashtable would not fit into main memory if you have lots of keys.
 
-Therefore keyvi uses several hashtables organized by a LRU (Least Recently Used) Cache: 
+Therefore keyvi uses several hashtables organized by a LRU (Least Recently Used) Cache:
 
-The 1st hashtable is filled with a limited number of entries, once full a new hash table is created. If the amount of 
+The 1st hashtable is filled with a limited number of entries, once full a new hash table is created. If the amount of
 hashtables reaches the limit the last hashtable is thrown away.
 
 To keep "good hashes": Each entry of a successful lookup in a lower hashtable will be moved to the top hashtable. Therefore
-states which often minimize will stay in memory, while states which do not minimize will be thrown away over time. 
+states which often minimize will stay in memory, while states which do not minimize will be thrown away over time.
 
 Code: [LRU Cache](/keyvi/src/cpp/dictionary/fsa/internal/lru_generation_cache.h)
 
 ### Compilation/Index Performance
 
-Apart from low-level optimizations like avoiding object copies, pooling, short string optimization, good hash function etc., 
+Apart from low-level optimizations like avoiding object copies, pooling, short string optimization, good hash function etc.,
 keyvi uses some optimization on the algorithm side.
 
 #### Minimization Stop
 
-As described in Construction the FSA is build from 'right to left', minimization only works this way. Once a minimization 
+As described in Construction the FSA is build from 'right to left', minimization only works this way. Once a minimization
 fails it is impossible to minimize the parent state. Therefore we stop minimization of the preceding states once it fails once.
 Note: we still store the fingerprints in the hashtable for later minimizations.
 
@@ -48,9 +48,9 @@ Note: The amount of memory is configurable in the compiler. Increasing the limit
 
 #### Packing
 
-Sparse Array Construction is one of the most demanding parts. To speedup compilation we make use of bit vectors, 
-sliding windows and the [De Bruijn](http://en.wikipedia.org/wiki/De_Bruijn_sequence) sequence to quickly find spots to pack 
-the data, or - if available - intrinsic compiler/CPU functions. 
+Sparse Array Construction is one of the most demanding parts. To speedup compilation we make use of bit vectors,
+sliding windows and the [De Bruijn](http://en.wikipedia.org/wiki/De_Bruijn_sequence) sequence to quickly find spots to pack
+the data, or - if available - intrinsic compiler/CPU functions.
 
 Code: [BitVector](/keyvi/src/cpp/dictionary/fsa/internal/bit_vector.h)
 
diff --git a/doc/usage/Building keyvi dictionaries with python.md b/doc/usage/Building keyvi dictionaries with python.md
index bace990c7..4119d383b 100644
--- a/doc/usage/Building keyvi dictionaries with python.md	
+++ b/doc/usage/Building keyvi dictionaries with python.md	
@@ -7,7 +7,7 @@ The compiler is also available from python keyvi:
 
     # repeat for every key
     compiler.Add("foo")
-    
+
     # finally compile
     compiler.Compile()
     compiler.WriteToFile("/tmp/test.kv")
@@ -15,7 +15,7 @@ The compiler is also available from python keyvi:
 Other available Compiler in `keyvi.compiler`
 
 type              | details
------------------ | --------------------------------------------------------------------------------------------- 
+----------------- | ---------------------------------------------------------------------------------------------
 integer           | CompletionDictionaryCompiler
 key-only          | KeyOnlyDictionaryCompiler
 string            | StringDictionaryCompiler
@@ -24,8 +24,7 @@ json              | JsonDictionaryCompiler
 For dictionaries with values, Add takes the value as second parameter:
 
     compiler.Add("foo", 42)
-    
+
 To ensure that you do not run out of disk space while compiling, set $TMPDIR to a disk with enough free space.
-    
-    export TMPDIR=/mnt/tmp
 
+    export TMPDIR=/mnt/tmp
diff --git a/doc/usage/Building keyvi dictionaries.md b/doc/usage/Building keyvi dictionaries.md
index 4feb2a0a6..b23c705c3 100644
--- a/doc/usage/Building keyvi dictionaries.md	
+++ b/doc/usage/Building keyvi dictionaries.md	
@@ -16,7 +16,7 @@ keyvicompiler shall be available now:
       -o [ --output-file ] arg              output file
       -m [ --memory-limit ] arg             amount of main memory to use
       -d [ --dictionary-type ] arg (=integer)
-                                            type of dictionary (integer (default), 
+                                            type of dictionary (integer (default),
                                             string, key-only)
 
 To compile simply run for example:
@@ -27,7 +27,7 @@ To compile simply run for example:
 #### The different formats
 
 type              | details
------------------ | --------------------------------------------------------------------------------------------- 
+----------------- | ---------------------------------------------------------------------------------------------
 integer           | Expects integer values (tab separated from the key)
 key-only          | Expects no values, just keys (e.g. for filters like the adult filter)
 string            | Expects string values (tab separated from key)
@@ -37,11 +37,11 @@ json              | Expects valid json values (dumped as string)
 #### Memory Limit
 
 The level of compression can depend on the amount of memory. If you create large dictionaries it might make a difference
- to allow the compiler the usage of more memory. This will not only speedup the sort phase but might also lead to 
+ to allow the compiler the usage of more memory. This will not only speedup the sort phase but might also lead to
  smaller dictionaries in the end. Per default the memory limit is set to 1 GB.
- 
+
 Note: The memory limit just sets the amount of memory the keyvi compiler can use for its minimization hashtables, in addition
-keyvi dictionary compiler needs more memory to persist the data. 
+keyvi dictionary compiler needs more memory to persist the data.
 
 #### Dumping keyvi dictionaries
 
diff --git a/doc/usage/Crashcourse.md b/doc/usage/Crashcourse.md
index 8f69139d3..b8a87ca03 100644
--- a/doc/usage/Crashcourse.md
+++ b/doc/usage/Crashcourse.md
@@ -7,35 +7,35 @@ After installation you should have `keyvi` executable available:
 Try:
 
     keyvi -h
-    
+
 Try in python:
-    
+
     import keyvi
-    
+
 ### First compile and decompile
 
 Open a text editor and put some keys in there, e.g.
-    
+
     keyvi
     is
     a
     key
     value
     index
-    
+
 Compile:
 
     keyvi compile <input_file> compiled.kv key-only
-    
+
 Dump:
-    
+
     keyvi dump compiled.kv dump.out
 
-After dumping, open the file dump.out in a text editor, it should contain your data. 
+After dumping, open the file dump.out in a text editor, it should contain your data.
 
 Check questions:
  * What is the difference to your input file?
- 
+
 #### Open the file in python
 
 All python examples assume python 3.
@@ -45,23 +45,23 @@ Do:
     from keyvi.dictionary import Dictionary
     d = Dictionary("compiled.kv")
     "keyvi" in d
-    
+
 should return True
-    
+
     match = d['keyvi']
 
 gives you a so called match object
-    
+
     dir(match)
- 
+
 shows all methods you can call on that object, e.g.
 
     match.GetMatchedString()
- 
+
 should return "keyvi"
 
 Match objects are the common return structure in keyvi. For this very simple example, the other methods are not useful. But with going deeper into more elaborated examples below, you will find how they can be used.
- 
+
 Check questions:
 
  * How fast does it load? Do you have an idea how loading works internally?
@@ -69,7 +69,7 @@ Check questions:
 
 ### Simple Statistics
 
-Both, the `keyvi` executable and the Python API provide an easy way to obtain the number of keys and values in a keyvi file. 
+Both, the `keyvi` executable and the Python API provide an easy way to obtain the number of keys and values in a keyvi file.
 
 For the just created `compiled.kv` file run:
 
@@ -103,7 +103,7 @@ Similarly with python, on the `Dictionary` object `d` the call `d.GetStatistics(
 Go to [lookup examples](/python/examples/lookup)
 
 Compile cities.tsv and run the tester:
-    
+
     keyvicompiler -i cities.tsv -o cities.kv -d key-only
     python text_lookup_tester.py
 
@@ -127,7 +127,7 @@ Check questions:
 
  * Compare values and unique value, whats the meaning of it?
 
-     
+
 With sharding (for distributed data indexes):
 
      compile_json.py -i your-input -o your-keyvi.kv -s 3
@@ -147,14 +147,14 @@ Compile and try:
     python prefix_completion_tester.py
 
 Query: '80s'
- 
-Now try:    
+
+Now try:
 
     keyvicompiler -i completion.tsv -o prefix-completion.kv
     python prefix_completion_tester.py
 
 Check questions:
- 
+
  * What's the difference between the 2?
  * What if you have more data?
  * Advanced: How does it work?
@@ -164,7 +164,7 @@ Check questions:
 Try:
 
     python prefix_completion_fuzzy_tester.py
-    
+
 and use misspelled queries like '80s movie wit sombies'
 
 #### Multiword Completion
@@ -172,11 +172,11 @@ and use misspelled queries like '80s movie wit sombies'
 Compile with:
 
     cat completion.tsv | python multiword_completion_writer.py
-    
+
 and try:
 
     python multiword_completion_tester.py
-    
+
 e.g. 'zombies movie'
 
 Check questions:
@@ -192,8 +192,7 @@ Go to [normalization examples](/python/examples/normalization)
 Compile with:
 
     keyvicompiler -i normalization.tsv -o normalization.kv -d string
-    
+
 and try:
 
     cat sample.txt | python normalize.py
-    
diff --git a/doc/usage/Keyvi Index with python.md b/doc/usage/Keyvi Index with python.md
index 7fec178ea..abe03db89 100644
--- a/doc/usage/Keyvi Index with python.md	
+++ b/doc/usage/Keyvi Index with python.md	
@@ -29,7 +29,7 @@ index.Set("a", "42")
 and get:
 
 ```
-m = index.Get('a') 
+m = index.Get('a')
 print(m.GetValue())
 ```
 
diff --git a/doc/usage/Using pykeyvi in EMR.md b/doc/usage/Using pykeyvi in EMR.md
index 35f654d30..2fb527d04 100644
--- a/doc/usage/Using pykeyvi in EMR.md	
+++ b/doc/usage/Using pykeyvi in EMR.md	
@@ -1,11 +1,11 @@
 ## Using keyvi in pyspark or mrjob
 
 
-Imagine you want to do some lookups in you map-reduce jobs like matching or extracting certain patterns - in fuzzy manner if you like - and your lookup table is huge. 
+Imagine you want to do some lookups in you map-reduce jobs like matching or extracting certain patterns - in fuzzy manner if you like - and your lookup table is huge.
 You could call a database or key value store remotely, but that kills performance and introduces a single point of failure in the otherwise distributed processing.
-With keyvi you can easily do that, given you are using a python based framework like mrjob or pyspark. 
+With keyvi you can easily do that, given you are using a python based framework like mrjob or pyspark.
 Due to the shared memory model keyvi indexes are just loaded once in memory, independent on the number of mappers on one machine.
-It works even if keyvi files are bigger than the main memory, for the price of some IO of course. 
+It works even if keyvi files are bigger than the main memory, for the price of some IO of course.
 In the end all calls will be local and do not entail any networking.
 
 ### Bootstrapping keyvi
diff --git a/python/LICENSE.txt b/python/LICENSE.txt
index 8f71f43fe..8dada3eda 100644
--- a/python/LICENSE.txt
+++ b/python/LICENSE.txt
@@ -199,4 +199,3 @@
    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.
-
diff --git a/sphinx-docs/_static/custom.css b/sphinx-docs/_static/custom.css
index f2e8ecacd..90bf4aa01 100644
--- a/sphinx-docs/_static/custom.css
+++ b/sphinx-docs/_static/custom.css
@@ -5,4 +5,4 @@
 /* Code snippets. */
 pre {
     background-color: #24292f;
-}
\ No newline at end of file
+}
diff --git a/sphinx-docs/conf_extra.py b/sphinx-docs/conf_extra.py
index 12ef1f414..799b2ac90 100644
--- a/sphinx-docs/conf_extra.py
+++ b/sphinx-docs/conf_extra.py
@@ -7,17 +7,19 @@
 html_static_path = [join(dirname(__file__), "_static")]
 
 html_theme_options = dict(
-    project_name= "keyvi",
-    logo= "logo-white.png",
-    logo_alt = "keyvi",
-    github_url = "https://github.com/KeyviDev/keyvi/tree/master/sphinx-docs/",
-    footer_links = ",".join([
-        "Github|https://github.com/KeyviDev/keyvi",
-        "Pypi|https://pypi.org/project/keyvi/",
-    ]),
- )
+    project_name="keyvi",
+    logo="logo-white.png",
+    logo_alt="keyvi",
+    github_url="https://github.com/KeyviDev/keyvi/tree/master/sphinx-docs/",
+    footer_links=",".join(
+        [
+            "Github|https://github.com/KeyviDev/keyvi",
+            "Pypi|https://pypi.org/project/keyvi/",
+        ]
+    ),
+)
 
 html_show_copyright = False
 html_last_updated_fmt = "%b %d, %Y"
 
-html_css_files = ["custom.css"]
\ No newline at end of file
+html_css_files = ["custom.css"]
diff --git a/sphinx-docs/cpp/dictionary_compiler.rst b/sphinx-docs/cpp/dictionary_compiler.rst
index 336a3b024..ee2388fed 100644
--- a/sphinx-docs/cpp/dictionary_compiler.rst
+++ b/sphinx-docs/cpp/dictionary_compiler.rst
@@ -1,6 +1,6 @@
 DictionaryCompiler
 ============================================
-   
+
 .. doxygenclass:: keyvi::dictionary::DictionaryCompiler
    :project: doxygen_keyvi
    :members:
diff --git a/sphinx-docs/index.rst b/sphinx-docs/index.rst
index 492132977..c5687848a 100644
--- a/sphinx-docs/index.rst
+++ b/sphinx-docs/index.rst
@@ -3,13 +3,13 @@
 Welcome to keyvi!
 =================
 
-Keyvi - the short form for "Key value index" is a key value store (KVS) optimized for size and lookup speed. The usage 
-of shared memory makes it scalable and resistant. The biggest difference to other stores is the underlying data 
-structure based on `finite state machine <https://en.wikipedia.org/wiki/Finite-state_machine>`_. Storage is very space 
-efficient, fast and by design makes various sorts of approximate matching be it fuzzy string matching or geo highly 
-efficient. The immutable FST data structure can be used stand-alone for static datasets. If you need online writes, 
-you can use keyvi index, a "near realtime index". The index can be used as embedded key value store, e.g. if you 
-already have a network stack in your application. A out of the box network enabled store is available with 
+Keyvi - the short form for "Key value index" is a key value store (KVS) optimized for size and lookup speed. The usage
+of shared memory makes it scalable and resistant. The biggest difference to other stores is the underlying data
+structure based on `finite state machine <https://en.wikipedia.org/wiki/Finite-state_machine>`_. Storage is very space
+efficient, fast and by design makes various sorts of approximate matching be it fuzzy string matching or geo highly
+efficient. The immutable FST data structure can be used stand-alone for static datasets. If you need online writes,
+you can use keyvi index, a "near realtime index". The index can be used as embedded key value store, e.g. if you
+already have a network stack in your application. A out of the box network enabled store is available with
 `keyvi-server <https://github.com/KeyviDev/keyvi-server>`_.
 
 The core of keyvi is written in C++, binding are available for Rust and Python.
@@ -28,6 +28,6 @@ API Documentation
 .. toctree::
    :maxdepth: 2
    :caption: Python API
-   
+
    python/dictionary
    python/index