Fixed all links

docs/source/Async-Process.md

@@ -75,7 +75,8 @@ line quite pointless for processing any data from the function. Instead one has
             print(r)
     ```
 
-- `at_return_kwargs` - an optional dictionary that will be fed as keyword arguments to the `at_return` callback.
+- `at_return_kwargs` - an optional dictionary that will be fed as keyword arguments to the
+`at_return` callback.
 - `at_err(e)` (the *errback*) is called if the asynchronous function fails and raises an exception.
   This exception is passed to the errback wrapped in a *Failure* object `e`. If you do not supply an
   errback of your own, Evennia will automatically add one that silently writes errors to the evennia
@@ -98,9 +99,9 @@ An example of making an asynchronous call from inside a [Command](./Commands) de
 
        key = "asynccommand"
     
-       def func(self):     
+       def func(self):
            
-           def long_running_function():  
+           def long_running_function():
                #[... lots of time-consuming code  ...]
                return final_value
            
@@ -111,12 +112,14 @@ An example of making an asynchronous call from inside a [Command](./Commands) de
                self.caller.msg("There was an error: %s" % e)
 
            # do the async call, setting all callbacks
-           utils.run_async(long_running_function, at_return=at_return_function, at_err=at_err_function) 
+           utils.run_async(long_running_function, at_return=at_return_function,
+at_err=at_err_function)
 ```
 
 That's it - from here on we can forget about `long_running_function` and go on with what else need
-to be done. *Whenever* it finishes, the `at_return_function` function will be called and the final value will
-pop up for us to see. If not we will see an error message. 
+to be done. *Whenever* it finishes, the `at_return_function` function will be called and the final
+value will
+pop up for us to see. If not we will see an error message.
 
 ## delay
 
@@ -145,9 +148,10 @@ You can also try the following snippet just see how it works:
 Wait 10 seconds and 'Test!' should be echoed back to you.
 
 
-## The @interactive decorator 
+## The @interactive decorator
 
-As of Evennia 0.9, the `@interactive` [decorator](https://realpython.com/primer-on-python-decorators/)
+As of Evennia 0.9, the `@interactive` [decorator](https://realpython.com/primer-on-python-
+decorators/)
 is available. This makes any function or method possible to 'pause' and/or await player input
 in an interactive way.
 
@@ -162,10 +166,10 @@ in an interactive way.
           yield(5)
           caller.msg("Now 5 seconds have passed.")
 
-          response = yield("Do you want to wait another 5 secs?")  
+          response = yield("Do you want to wait another 5 secs?")
 
           if response.lower() not in ("yes", "y"):
-              break 
+              break
 ```
 
 The `@interactive` decorator gives the function the ability to pause. The use
@@ -179,15 +183,15 @@ allows you to ask the user for input. You can then process the input, just like
 you would if you used the Python `input` function. There is one caveat to this
 functionality though - _it will only work if the function/method has an
 argument named exactly `caller`_.  This is because internally Evennia will look
-for the `caller` argument and treat that as the source of input. 
+for the `caller` argument and treat that as the source of input.
 
 All of this makes the `@interactive` decorator very useful. But it comes with a
 few caveats. Notably, decorating a function/method with `@interactive` turns it
 into a Python [generator](https://wiki.python.org/moin/Generators). The most
 common issue is that you cannot use `return <value>` from a generator (just an
 empty `return` works). To return a value from a function/method you have decorated
-with `@interactive`, you must instead use a special Twisted function 
-`twisted.internet.defer.returnValue`. Evennia also makes this function 
+with `@interactive`, you must instead use a special Twisted function
+`twisted.internet.defer.returnValue`. Evennia also makes this function
 conveniently available from `evennia.utils`:
 
 ```python
@@ -196,7 +200,7 @@ conveniently available from `evennia.utils`:
     @interactive
     def myfunc():
 
-        # ... 
+        # ...
         result = 10
 
         # this must be used instead of `return result`
@@ -223,7 +227,8 @@ expected, but they may appear with delays or in groups.
 ## Further reading
 
 Technically, `run_async` is just a very thin and simplified wrapper around a
-[Twisted Deferred](http://twistedmatrix.com/documents/9.0.0/core/howto/defer.html) object; the wrapper sets
+[Twisted Deferred](http://twistedmatrix.com/documents/9.0.0/core/howto/defer.html) object; the
+wrapper sets
 up a default errback also if none is supplied. If you know what you are doing there is nothing
 stopping you from bypassing the utility function, building a more sophisticated callback chain after
 your own liking.