Update to support 1.0.1

Author: maxnz

README.md

@@ -1,138 +1,33 @@
-# AnimatedLEDStrip Client Library for Python
-
 [![Build Status](https://travis-ci.com/AnimatedLEDStrip/client-python.svg?branch=master)](https://travis-ci.com/AnimatedLEDStrip/client-python)
 [![PyPI](https://img.shields.io/pypi/v/animatedledstrip-client.svg)](https://pypi.python.org/pypi/animatedledstrip-client)
 [![codecov](https://codecov.io/gh/AnimatedLEDStrip/client-python/branch/master/graph/badge.svg)](https://codecov.io/gh/AnimatedLEDStrip/client-python)
 
-This library allows a Python 3 client to connect to an AnimatedLEDStrip server, allowing the client to send animations to the server and receive currently running animations from the server, among other information.
+# AnimatedLEDStrip Client Library for Python
+
+This library allows a Python 3 client to communicate with an AnimatedLEDStrip server.
 
 ## Adding the Library to a Project
+
 The library is available via pip:
 
 ```bash
 pip3 install animatedledstrip-client
 ```
 
 ## Creating an `AnimationSender`
-An `AnimationSender` is constructed with two arguments:
-- `ip_address`: The IP address of the server (as a string)
-- `port_num`: The port that the client should connect to (as an integer)
 
-```python
-from animatedledstrip import AnimationSender
-
-sender = AnimationSender("10.0.0.254", 5)
-```
-
-## Starting an `AnimationSender`
-An `AnimationSender` is started by calling the `start()` method on the instance.
+An `ALSHttpClient` is created with `ALSHttpClient(ip_address)`.
 
 ```python
-sender.start()
-```
+from animatedledstrip import ALSHttpClient
 
-## Stopping the `AnimationSender`
-An `AnimationSender` is stopped by calling the `end()` method on the instance.
-
-```python
-sender.end()
+sender = ALSHttpClient('10.0.0.254')
 ```
 
-## Sending Data
-An animation can be sent to the server by creating an instance of the `AnimationData` class, then calling `send_animation()` with the instance as the argument.
+## Communicating with the Server
 
-```python
-from animatedledstrip import AnimationData, ColorContainer
-
-color = ColorContainer()
-color.add_color(0xFF)
-color.add_color(0xFF00)
-
-data = AnimationData()
-data.add_color(color)
-
-sender.send_data(data)
-```
-
-#### `AnimationData` type notes
-The Python library uses the following values for `continuous` and `direction`:
-- `continuous`: `None`, `True`, `False`
-- `direction`: `Direction.FORWARD`, `Direction.BACKWARD`
-
-## Receiving Data
-Received animations are saved to the `running_animations` dict and removed when an `EndAnimation` is received for that animation.
-
-In addition, the Python library uses callbacks that run functions to allow you to specify what to do with data that is received.
-
-### ReceiveCallback
-The `receiveCallback` is called whenever the sender receives `bytes` from the server.
-The `bytes` are passed to your callback.
-Use the `newAnimationDataCallback`, `newAnimationInfoCallback`, `newEndAnimationCallback`, `newSectionCallback` *(Coming soon)* and `newStripInfoCallback` *(Coming soon)* callbacks to handle each type of data.
-Runs before `newAnimationDataCallback`, `newAnimationInfoCallback`, `newEndAnimationCallback`, `newSectionCallback` and `newStripInfoCallback`.
-
-```python
-def receiveData(data: bytes):
-    # Your code here
-
-sender.on_receive_callback = receiveData
-```
+This library follows the conventions laid out for [AnimatedLEDStrip client libraries](https://animatedledstrip.github.io/client-libraries), with the following modifications:
 
-### NewAnimationDataCallback
-The `newAnimationDataCallback` is called whenever the sender receives an `AnimationData` instance from the server.
-The `AnimationData` instance is passed to your callback.
-Runs after the `receiveCallback`.
-
-```python
-def processAnimationData(data: 'AnimationData'):
-    # Your code here
-
-sender.on_new_animation_data_callback = processAnimationData
-```
-
-### NewAnimationInfoCallback
-The `newAnimationInfoCallback` is called whenever the sender receives an `AnimationInfo` instance from the server.
-The `AnimationInfo` instance is passed to your callback.
-Runs after the `receiveCallback`.
-
-```python
-def handleNewAnimationInfo(info: 'AnimationInfo'):
-    # Your code here
-
-sender.on_new_animation_info_callback = handleNewAnimationInfo
-```
-
-### NewEndAnimationCallback
-The `newEndAnimationCallback` is called whenever the sender receives an `EndAnimation` instance from the server.
-The `EndAnimation` instance is passed to your callback.
-Runs after the `receiveCallback`.
-
-```python
-def handleEndAnimation(anim: 'EndAnimation'):
-    # Your code here
-
-sender.on_new_end_animation_callback = handleEndAnimation
-```
-
-### NewSectionCallback *(Coming soon)*
-The `newSectionCallback` is called whenever the sender receives a `Section` instance from the server.
-The `Section` instance is passed to your callback.
-Runs after the `receiveCallback`.
-
-```python
-def newSectionHandler(sect: 'Section'):
-    # Your code here
-
-sender.on_new_section_callback = newSectionHandler
-```
-
-### NewStripInfoCallback *(Coming soon)*
-The `newStripInfoCallback` is called whenever the sender receives a `StripInfo` instance from the server.
-The `StripInfo` instance is passed to your callback.
-Runs after the `receiveCallback`.
-
-```python
-def processStripInfo(info: 'StripInfo'):
-    # Your code here
-
-sender.on_new_strip_info_callback = processStripInfo
-```
+- Function names and class variables are in snake case to follow Python style conventions
+- `get_supported_animations_dict` is provided as an alias for `get_supported_animations_map`
+- `get_sections_dict` is provided as an alias for `get_sections_map`

animatedledstrip/__init__.py

@@ -1,14 +1,11 @@
+from .als_http_client import ALSHttpClient
 from .animation_info import AnimationInfo
-from .animation_sender import AnimationSender
-from .client_params import ClientParams
+from .animation_to_run_params import AnimationToRunParams
 from .color_container import ColorContainer, PreparedColorContainer
-from .command import Command
-from .current_strip_color import CurrentStripColor
 from .distance import AbsoluteDistance, PercentDistance
-from .end_animation import EndAnimation
 from .equation import Equation
 from .location import Location
-from .message import Message
+from .rotation import DegreesRotation, RadiansRotation
 from .running_animation_params import RunningAnimationParams
 from .section import Section
 from .strip_info import StripInfo

animatedledstrip/als_http_client.py

@@ -17,18 +17,20 @@
 #  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 #  THE SOFTWARE.
+
 import json
 from urllib.request import Request, urlopen
-from typing import TYPE_CHECKING, List, Dict, Any
+from typing import Any, Dict, List, TYPE_CHECKING
 
-from animatedledstrip import RunningAnimationParams, Section, StripInfo
-from animatedledstrip.animation_to_run_params import AnimationToRunParams
 from animatedledstrip.json_decoder import ALSJsonDecoder
 from animatedledstrip.json_encoder import ALSJsonEncoder
 
 if TYPE_CHECKING:
     from animatedledstrip.animation_info import AnimationInfo
-    from animatedledstrip.current_strip_color import CurrentStripColor
+    from animatedledstrip.animation_to_run_params import AnimationToRunParams
+    from animatedledstrip.running_animation_params import RunningAnimationParams
+    from animatedledstrip.section import Section
+    from animatedledstrip.strip_info import StripInfo
 
 
 class ALSHttpClient:
@@ -54,9 +56,9 @@ def _delete_data(self, url: str) -> Any:
         return urlopen(Request(self._resolve_url(url), method='DELETE')).read()
 
     def get_animation_info(self, anim_name: str) -> 'AnimationInfo':
-        return self.decoder.decode_with_type(self._get_data('/animation/' + anim_name), 'AnimationInfo')
+        return self.decoder.decode_object_with_type(self._get_data('/animation/' + anim_name), 'AnimationInfo')
 
-    def get_supported_animation_names(self) -> List[str]:
+    def get_supported_animations_names(self) -> List[str]:
         return json.loads(self._get_data('/animations/names'))
 
     def get_supported_animations(self) -> List['AnimationInfo']:
@@ -75,10 +77,10 @@ def get_running_animations_ids(self) -> List[str]:
         return json.loads(self._get_data('/running/ids'))
 
     def get_running_animation_params(self, anim_id: str) -> 'RunningAnimationParams':
-        return self.decoder.decode_with_type(self._get_data('/running/' + anim_id), 'RunningAnimationParams')
+        return self.decoder.decode_object_with_type(self._get_data('/running/' + anim_id), 'RunningAnimationParams')
 
     def end_animation(self, anim_id: str) -> 'RunningAnimationParams':
-        return self.decoder.decode_with_type(self._delete_data('/running/' + anim_id), 'RunningAnimationParams')
+        return self.decoder.decode_object_with_type(self._delete_data('/running/' + anim_id), 'RunningAnimationParams')
 
     def end_animation_from_params(self, anim_params: 'RunningAnimationParams') -> 'RunningAnimationParams':
         return self.end_animation(anim_params.anim_id)
@@ -92,23 +94,23 @@ def get_sections_map(self) -> Dict[str, 'Section']:
     def get_sections_dict(self) -> Dict[str, 'Section']:
         return self.get_sections_map()
 
-    def get_section(self, section_id: str) -> 'Section':
-        return self.decoder.decode_with_type(self._get_data('/sections/' + section_id), 'Section')
+    def get_section(self, section_name: str) -> 'Section':
+        return self.decoder.decode_object_with_type(self._get_data('/sections/' + section_name), 'Section')
 
     def get_full_strip_section(self) -> 'Section':
         return self.get_section('fullStrip')
 
     def create_new_section(self, new_section: 'Section') -> 'Section':
-        return self.decoder.decode_with_type(self._post_data('/sections', new_section), 'Section')
+        return self.decoder.decode_object_with_type(self._post_data('/sections', new_section), 'Section')
 
     def start_animation(self, anim_params: 'AnimationToRunParams') -> 'RunningAnimationParams':
-        return self.decoder.decode_with_type(self._post_data('/start', anim_params), 'RunningAnimationParams')
+        return self.decoder.decode_object_with_type(self._post_data('/start', anim_params), 'RunningAnimationParams')
 
     def get_strip_info(self) -> 'StripInfo':
-        return self.decoder.decode_with_type(self._get_data('/strip/info'), 'StripInfo')
+        return self.decoder.decode_object_with_type(self._get_data('/strip/info'), 'StripInfo')
 
-    def get_current_strip_color(self) -> 'CurrentStripColor':
-        return self.decoder.decode_with_type(self._get_data('/strip/color'), 'CurrentStripColor')
+    def get_current_strip_color(self) -> List[int]:
+        return json.loads(self._get_data('/strip/color'))
 
     def clear_strip(self):
         # TODO: Fix 404