Major rework, a lot more intuitive and user friendly!

.gitignore

@@ -8,6 +8,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+test
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
@@ -328,3 +329,131 @@ ASALocalRun/
 
 # MFractors (Xamarin productivity tool) working folder 
 .mfractor/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

README.md

@@ -1,28 +1,85 @@
-# interception_py
-This is a port (not a [wrapper][wrp]) of [interception][c_ception] dll to python, it communicates directly with interception's driver
+# pyinterception
+This is a greatly reworked version of [interception_py][wrp], a python port for [interception][c_ception], which is now obsolete and points here instead.
 
-### why not using the wrapper?
-* it's very slow and some strokes are lost
-* fast strokes made python crash (some heap allocation errors)
+The Interception API aims to build a portable programming interface that allows one to intercept and control a range of input devices.
 
-To make it run you should install the driver from [c-interception][c_ception]
+## How to install
+Pyinterception is now available on PyPi under the name `interception-python`! So simply `pip install interception-python`.
+
+
+## Why use interception?
+Did you ever try to send inputs to an application or game and, well, nothing happened? Sure, in alot of cases this is resolved by running your
+code with administrative privileges, but this is not always the case.
+
+Take parsec as example, you are entirely unable to send any simulated inputs to parsec, but it has no problems with real inputs, so why is this?
+
+Long story short, injected inputs actually have a `LowLevelKeyHookInjected` (0x10) flag. This flag will **always** be set when sending an Input with `SendInput` or the even older `mouse_event` and `keyb_event`. This flag is not at all hard to pick up for programs, if you have python3.7 and pyHook installed, you can try it yourself using this code:
 
-### example
 ```py
+import pyHook
+import pythoncom
+
+def keyb_event(event):
+
+    if event.flags & 0x10:
+        print("Injected input sent")
+    else:
+        print("Real input sent")
+
+    return True
+
+hm = pyHook.HookManager()
+hm.KeyDown = keyb_event
+
+hm.HookKeyboard()
+
+pythoncom.PumpMessages()
+```
+You will quickly see that, no matter what conventional python library you try, all of them will be flagged as injected. Thats because in the end, they all either rely on `SendInput` or `keyb_event` | `mouse_event`.
+
+Why is this bad? Well, it's not always bad. If whatever you're sending inputs to currently works fine, and you are not worried about getting flagged by some sort of anti-cheat, then by all means its totally fine to stick to pyautogui / pydirectinput.
+
+Alright, enough about that, onto the important shit.
+
+## Why use this fork?
+- Extremely simple interface, comparable to pyautogui / pydirectinput
+- Dynamic keyboard adjustment for all kinds of layouts
+- Refactored in a much more readable and documented fashion
+- I work with loads of automation first hand so there is alot of QoL features.
+
+## How to use?
+First of all, you absolutely need to install the [interception-driver][c_ception], otherwise none of this will work. It's a very simple install.
+
+Now, once you have all of that set up, you can go ahead and import `interception`. 
+The first thing you need to understand is that you have 10 different numbers for keyboard / mouse, and any of them could be the device you are
+using. You can observe this by running the following program:
+```py
+import interception
+
+interception.capture_keyboard()
+interception.capture_mouse()
+```
+You can cancel the capture by pressing the ESC key, but every time you press a key or click with the mouse, you can see the intercepted event in the terminal.
+The event consists of different kinds of flags and states, but also of the number of your device we just talked about.
+
+To make sure that interception can actively send inputs from the correct devices, you have to set the correct devices. You can do this by manually checking the output,
+but that gets pretty annoying as they can and will change sometimes. To make this easier, pyinterception has a method that will automatically capture a working device:
+```py
+import interception
+
+interception.auto_capture_devices(keyboard=True, mouse=True)
+```
+So, now you can begin to send inputs, just like you are used to it from pyautogui or pydirectinput!
+```py
+interception.move_to(960, 540)
+
+with interception.hold_key("shift"):
+    interception.press("a")
 
-from interception import  *
-
-if __name__ == "__main__":
-    c = interception()
-    c.set_filter(interception.is_keyboard,interception_filter_key_state.INTERCEPTION_FILTER_KEY_UP.value)
-    while True:
-        device = c.wait()
-        stroke = c.receive(device)
-        if type(stroke) is key_stroke:
-            print(stroke.code)
-        c.send(device,stroke)
+interception.click(120, 160, button="right", delay=1)
 ```
 
+Have fun :D
 
-[wrp]: https://github.com/cobrce/interception_wrapper
+[wrp]: https://github.com/cobrce/interception_py
 [c_ception]: https://github.com/oblitum/Interception