fix a buch of flake8 errors

Author: attwad

docs/conf.py

@@ -180,4 +180,4 @@
 epub_exclude_files = ['search.html']
 
 
-# -- Extension configuration -------------------------------------------------
+# -- Extension configuration -------------------------------------------------

examples/dispatcher.py

@@ -1,5 +1,7 @@
 from pythonosc.dispatcher import Dispatcher
 from typing import List, Any
+from pythonosc.osc_server import BlockingOSCUDPServer
+from pythonosc.udp_client import SimpleUDPClient
 
 dispatcher = Dispatcher()
 
@@ -22,8 +24,6 @@ def set_filter(address: str, *args: List[Any]) -> None:
 dispatcher.map("/filter*", set_filter)  # Map wildcard address to set_filter function
 
 # Set up server and client for testing
-from pythonosc.osc_server import BlockingOSCUDPServer
-from pythonosc.udp_client import SimpleUDPClient
 
 server = BlockingOSCUDPServer(("127.0.0.1", 1337), dispatcher)
 client = SimpleUDPClient("127.0.0.1", 1337)

examples/simple_2way.py

@@ -1,13 +1,12 @@
 """Small example OSC server anbd client combined
-This program listens to serveral addresses and print if there is an input. 
+This program listens to serveral addresses and print if there is an input.
 It also transmits on a different port at the same time random values to different addresses.
 This can be used to demonstrate concurrent send and recieve over OSC
 """
 
 import argparse
 import random
 import time
-import math
 import threading
 
 from pythonosc import udp_client
@@ -22,6 +21,7 @@ def print_fader_handler(unused_addr, args, value):
 def print_xy_fader_handler(unused_addr, args, value1, value2):
     print("[{0}] ~ {1:0.2f} ~ {2:0.2f}".format(args[0], value2, value1))
 
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--serverip", default="127.0.0.1", help="The ip to listen on")
@@ -30,24 +30,24 @@ def print_xy_fader_handler(unused_addr, args, value1, value2):
     parser.add_argument("--clientport", type=int, default=5006, help="The port the OSC Client is listening on")
     args = parser.parse_args()
 
-
-    # listen to addresses and print changes in values 
+    # listen to addresses and print changes in values
     dispatcher = Dispatcher()
     dispatcher.map("/1/push2", print)
     dispatcher.map("/1/fader1", print_fader_handler, "Focus")
     dispatcher.map("/1/fader2", print_fader_handler, "Zoom")
     dispatcher.map("/1/xy1", print_xy_fader_handler, "Pan-Tilt")
     dispatcher.map("/ping", print)
 
-def start_server(ip, port):
 
+def start_server(ip, port):
     print("Starting Server")
     server = osc_server.ThreadingOSCUDPServer(
         (ip, port), dispatcher)
     print("Serving on {}".format(server.server_address))
     thread = threading.Thread(target=server.serve_forever)
     thread.start()
 
+
 def start_client(ip, port):
     print("Starting Client")
     client = udp_client.SimpleUDPClient(ip, port)
@@ -57,16 +57,13 @@ def start_client(ip, port):
 
 
 # send random values between 0-1 to the three addresses
-def random_values(client):        
+def random_values(client):
     while True:
         for x in range(10):
             client.send_message("/1/fader2", random.random())
             client.send_message("/1/fader1", random.random())
             client.send_message("/1/xy1", [random.random(), random.random()])
             time.sleep(.5)
 
-
 start_server(args.serverip, args.serverport)
 start_client(args.clientip, args.clientport)
-
-

examples/simple_client.py

@@ -7,7 +7,6 @@
 import random
 import time
 
-from pythonosc import osc_message_builder
 from pythonosc import udp_client
 
 if __name__ == "__main__":

pythonosc/osc_message_builder.py

@@ -7,9 +7,11 @@
 
 ArgValue = Union[str, bytes, bool, int, float, osc_types.MidiPacket, list]
 
+
 class BuildError(Exception):
     """Error raised when an incomplete message is trying to be built."""
 
+
 class OscMessageBuilder(object):
     """Builds arbitrary OscMessage instances."""
 
@@ -79,7 +81,7 @@ def add_arg(self, arg_value: ArgValue, arg_type: Optional[str] = None) -> None:
         if arg_type and not self._valid_type(arg_type):
             raise ValueError(
                 'arg_type must be one of {}, or an array of valid types'
-                    .format(self._SUPPORTED_ARG_TYPES))
+                .format(self._SUPPORTED_ARG_TYPES))
         if not arg_type:
             arg_type = self._get_arg_type(arg_value)
         if isinstance(arg_type, list):

pythonosc/osc_server.py

@@ -55,7 +55,7 @@ def __init__(self, server_address: Tuple[str, int], dispatcher: Dispatcher, bind
         Args:
             server_address: IP and port of server
             dispatcher: Dispatcher this server will use
-            (optional) bind_and_activate: default=True defines if the server has to start on call of constructor  
+            (optional) bind_and_activate: default=True defines if the server has to start on call of constructor
         """
         super().__init__(server_address, _UDPHandler, bind_and_activate)
         self._dispatcher = dispatcher

pythonosc/parsing/ntp.py

@@ -28,20 +28,18 @@
 
 
 class NtpError(Exception):
-  """Base class for ntp module errors."""
+    """Base class for ntp module errors."""
 
 
 def parse_timestamp(timestamp: int) -> Timestamp:
-    """Parse NTP timestamp as Timetag.
-    """
+    """Parse NTP timestamp as Timetag."""
     seconds = timestamp >> 32
     fraction = timestamp & 0xFFFFFFFF
     return Timestamp(seconds, fraction)
 
 
 def ntp_to_system_time(timestamp: bytes) -> float:
-    """Convert a NTP timestamp to system time in seconds.
-    """
+    """Convert a NTP timestamp to system time in seconds."""
     try:
         timestamp = struct.unpack('>Q', timestamp)[0]
     except Exception as e:
@@ -50,22 +48,19 @@ def ntp_to_system_time(timestamp: bytes) -> float:
 
 
 def system_time_to_ntp(seconds: float) -> bytes:
-    """Convert a system time in seconds to NTP timestamp.
-    """
+    """Convert a system time in seconds to NTP timestamp."""
     try:
-      seconds = seconds + _NTP_DELTA
+        seconds = seconds + _NTP_DELTA
     except TypeError as e:
-      raise NtpError(e)
+        raise NtpError(e)
     return struct.pack('>Q', int(seconds * _SECONDS_TO_NTP_TIMESTAMP))
 
 
 def ntp_time_to_system_epoch(seconds: float) -> float:
-    """Convert a NTP time in seconds to system time in seconds.
-    """
+    """Convert a NTP time in seconds to system time in seconds."""
     return seconds - _NTP_DELTA
 
 
 def system_time_to_ntp_epoch(seconds: float) -> float:
-    """Convert a system time in seconds to NTP time in seconds.
-    """
+    """Convert a system time in seconds to NTP time in seconds."""
     return seconds + _NTP_DELTA

pythonosc/parsing/osc_types.py

@@ -3,7 +3,7 @@
 import struct
 
 from pythonosc.parsing import ntp
-from datetime import datetime, timedelta, date
+from datetime import datetime, timedelta
 
 from typing import Union, Tuple, cast
 

pythonosc/test/parsing/test_osc_types.py

@@ -125,7 +125,7 @@ class TestMidi(unittest.TestCase):
     def test_get_midi(self):
         cases = {
             b"\x00\x00\x00\x00": ((0, 0, 0, 0), 4),
-            b"\x00\x00\x00\x02": ((0, 0, 0, 1), 4),
+            b"\x00\x00\x00\x01": ((0, 0, 0, 1), 4),
             b"\x00\x00\x00\x02": ((0, 0, 0, 2), 4),
             b"\x00\x00\x00\x03": ((0, 0, 0, 3), 4),
 

pythonosc/test/test_dispatcher.py

@@ -142,11 +142,11 @@ def test_unmap_exception(self):
         def dummyhandler():
             pass
 
-        with self.assertRaises(ValueError) as context:
+        with self.assertRaises(ValueError):
             self.dispatcher.unmap("/unmap/exception", dummyhandler)
 
         handlerobj = self.dispatcher.map("/unmap/somethingelse", dummyhandler())
-        with self.assertRaises(ValueError) as context:
+        with self.assertRaises(ValueError):
             self.dispatcher.unmap("/unmap/exception", handlerobj)