ovos-skill-mark1-ctrl 0.0.1__tar.gz

ovos_skill_mark1_ctrl-0.0.1/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2018 Matthew Scholefield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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.
+

ovos_skill_mark1_ctrl-0.0.1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: ovos-skill-mark1-ctrl
+Version: 0.0.1
+Summary: EnclosureControlSkill
+Home-page: https://github.com/OVOSHatchery/ovos-skill-mark1-ctrl
+Author: OpenVoiceOS
+Author-email: jarbasai@mailfence.com
+License: Apache2.0
+Keywords: ovos skill plugin
+License-File: LICENSE
+Requires-Dist: ovos-color-parser>=0.0.8a1
+Requires-Dist: ovos-i2c-detection>=0.0.6a1
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

ovos_skill_mark1_ctrl-0.0.1/README.md

@@ -0,0 +1,39 @@
+## Mark1 Enclosure Control
+
+Controls the enclosure api vocally
+
+## Description
+
+The Mycroft Mark 1 has several unique capabilities which this Skill lets you control.
+
+The Mark 1 has beautiful eyes -- and you get to pick their color!  Set them to
+a named color ("blue", "magenta", "teal", etc) or any color using RGB values.
+Please see the [ovos-color-parser](https://github.com/OpenVoiceOS/ovos-color-parser)
+for more options
+
+
+## Examples
+
+* "Set your eye color to green"
+* "Set a custom eye color" (you'll be prompted for values)
+* "Dim to 50%"
+* "look up"
+* "look down"
+* "look left"
+* "look right"
+* "look left and right"
+* "look up and down"
+* "reset enclosure"
+* "narrow your eyes"
+* "spin your eyes"
+* "blink your eyes"
+* "smile animation"
+* "listen animation"
+* "think animation"
+
+
+## Credits
+
+JarbasAI
+
+MycroftAI - https://github.com/MycroftAI/mycroft-mark-1

ovos_skill_mark1_ctrl-0.0.1/__init__.py

@@ -0,0 +1,476 @@
+import random
+import time
+from ast import literal_eval as parse_tuple
+from ovos_color_parser import color_from_description, sRGBAColor
+from ovos_utils import create_daemon, classproperty
+from ovos_utils.log import LOG
+from ovos_utils.process_utils import RuntimeRequirements
+from ovos_workshop.decorators import intent_handler
+from ovos_workshop.intents import IntentBuilder
+from ovos_workshop.skills import OVOSSkill
+from ovos_bus_client.message import Message
+from ovos_i2c_detection import is_mark_1
+from threading import Thread
+
+
+def _hex_to_rgb(_hex):
+    """ Convert hex color code to RGB tuple
+    Args:
+        hex (str): Hex color string, e.g '#ff12ff' or 'ff12ff'
+    Returns:
+        (rgb): tuple i.e (123, 200, 155) or None
+    """
+    try:
+        if '#' in _hex:
+            _hex = _hex.replace('#', "").strip()
+        if len(_hex) != 6:
+            return None
+        (r, g, b) = int(_hex[0:2], 16), int(_hex[2:4], 16), int(_hex[4:6], 16)
+        return (r, g, b)
+    except Exception:
+        return None
+
+class EnclosureControlSkill(OVOSSkill):
+    def __init__(self, *args, **kwargs):
+        if not is_mark_1():
+            LOG.error("This device is not a Mark 1.  It is suggested to uninstall this skill")
+            raise NotImplementedError("Purposeful exception because not on a Mark 1 device")
+        super().__init__(*args, **kwargs)
+        self.thread = None
+        self.playing = False
+        self.animations = []
+        self.add_event('mycroft.eyes.default', self.handle_default_eyes)
+        self.add_event('mycroft.ready', self.handle_default_eyes)
+
+    @classproperty
+    def runtime_requirements(self):
+        return RuntimeRequirements(internet_before_load=False,
+                                   network_before_load=False,
+                                   gui_before_load=False,
+                                   requires_internet=False,
+                                   requires_network=False,
+                                   requires_gui=False,
+                                   no_internet_fallback=True,
+                                   no_network_fallback=True,
+                                   no_gui_fallback=True)
+    
+    @property
+    def crazy_eyes_animation(self):
+        choices = [(self.enclosure.eyes_look, "d"),
+                   (self.enclosure.eyes_look, "u"),
+                   (self.enclosure.eyes_look, "l"),
+                   (self.enclosure.eyes_look, "r"),
+                   (self.enclosure.eyes_color, (255, 0, 0)),
+                   (self.enclosure.eyes_color, (255, 0, 255)),
+                   (self.enclosure.eyes_color, (255, 255, 255)),
+                   (self.enclosure.eyes_color, (0, 0, 255)),
+                   (self.enclosure.eyes_color, (0, 255, 0)),
+                   (self.enclosure.eyes_color, (255, 255, 0)),
+                   (self.enclosure.eyes_color, (0, 255, 255)),
+                   (self.enclosure.eyes_spin, None),
+                   (self.enclosure.eyes_narrow, None),
+                   (self.enclosure.eyes_on, None),
+                   (self.enclosure.eyes_off, None),
+                   (self.enclosure.eyes_blink, None)]
+
+        anim = []
+        for i in range(0, 10):
+            frame = random.choice(choices)
+            anim.append(self.animate(i, 3, frame[0], frame[1]))
+        return anim
+
+    @property
+    def up_down_animation(self):
+        return [
+            self.animate(2, 6, self.enclosure.eyes_look, "d"),
+            self.animate(4, 6, self.enclosure.eyes_look, "u"),
+
+        ]
+
+    @property
+    def left_right_animation(self):
+        return [
+            self.animate(2, 6, self.enclosure.eyes_look, "l"),
+            self.animate(4, 6, self.enclosure.eyes_look, "r"),
+
+        ]
+
+    @staticmethod
+    def animate(t, often, func, *args):
+        '''
+        Args:
+            t (int) : seconds from now to begin the frame (secs)
+            often (int/string): (int) how often to repeat the frame (secs)
+                                (str) when to trigger, relative to the clock,
+                                      for synchronized repetitions
+            func: the function to invoke
+            *args: arguments to pass to func
+        '''
+        return {
+            "time": time.time() + t,
+            "often": often,
+            "func": func,
+            "args": args
+        }
+
+    @staticmethod
+    def _get_time(often, t):
+        return often - t % often
+
+    def run(self):
+        """
+        animation thread while performing speedtest
+
+        """
+
+        while self.playing:
+            for animation in self.animations:
+                if animation["time"] <= time.time():
+                    # Execute animation action
+                    animation["func"](*animation["args"])
+
+                    # Adjust time for next loop
+                    if type(animation["often"]) is int:
+                        animation["time"] = time.time() + animation["often"]
+                    else:
+                        often = int(animation["often"])
+                        t = animation["time"]
+                        animation["time"] = time.time() + self._get_time(
+                            often, t)
+            time.sleep(0.1)
+
+        self.thread = None
+        self.enclosure.activate_mouth_events()
+        self.enclosure.mouth_reset()
+        self.enclosure.eyes_reset()
+
+    def play_animation(self, animation=None):
+        animation = animation or self.up_down_animation
+        if not self.thread:
+            self.playing = True
+
+            # Display info on a screen
+            self.enclosure.deactivate_mouth_events()
+
+            # Build the list of animation actions to run
+            self.animations = animation
+            self.thread = create_daemon(self.run)
+
+    @intent_handler(IntentBuilder("EnclosureLookRight")
+                    .require("look").require("right")
+                    .optionally("enclosure"))
+    def handle_look_right(self, message):
+        self.speak("looking right")
+        self.enclosure.eyes_look("r")
+
+    @intent_handler(IntentBuilder("EnclosureLookLeft")
+                    .require("look").require("left").optionally("enclosure"))
+    def handle_look_left(self, message):
+        self.speak("looking left")
+        self.enclosure.eyes_look("l")
+
+    @intent_handler(IntentBuilder("EnclosureLookUp")
+                    .require("look").require("up").optionally("enclosure"))
+    def handle_look_up(self, message):
+        self.speak("looking up")
+        self.enclosure.eyes_look("u")
+
+    @intent_handler(IntentBuilder("EnclosureLookDown")
+                    .require("look").require("down").optionally("enclosure"))
+    def handle_look_down(self, message):
+        self.speak("looking down")
+        self.enclosure.eyes_look("d")
+
+    @intent_handler(IntentBuilder("EnclosureLookUpDown")
+                    .require("look").require("up")
+                    .require("down").optionally("enclosure")
+                    .optionally("animation"))
+    def handle_look_up_down(self, message):
+        self.speak("up and down, up and down")
+        self.play_animation(self.up_down_animation)
+
+    @intent_handler(IntentBuilder("EnclosureLookLeftRight")
+                    .require("look").require("right")
+                    .require("left").optionally("enclosure")
+                    .optionally("animation"))
+    def handle_look_left_right(self, message):
+        self.speak("left and right, left and right")
+        self.play_animation(self.left_right_animation)
+
+    @intent_handler(IntentBuilder("EnclosureEyesBlink")
+                    .require("blink").one_of("eyes", "animation")
+                    .optionally("enclosure").optionally("right")
+                    .optionally("left"))
+    def handle_blink_eyes(self, message):
+        for i in range(0, 10):
+            if "right" in message.data:
+                self.enclosure.eyes_blink("r")
+            if "left" in message.data:
+                self.enclosure.eyes_blink("l")
+            else:
+                self.enclosure.eyes_blink("b")
+        self.speak("so this is what it feels like having low F P S")
+
+    @intent_handler(IntentBuilder("EnclosureEyesSpin")
+                    .require("spin").one_of("eyes", "animation")
+                    .optionally("enclosure"))
+    def handle_spin_eyes(self, message):
+        self.speak("around the world, here i go")
+        self.enclosure.eyes_spin()
+
+    @intent_handler(IntentBuilder("EnclosureEyesNarrow")
+                    .require("narrow").require("eyes")
+                    .optionally("enclosure"))
+    def handle_narrow_eyes(self, message):
+        self.speak("this is my evil face")
+        self.enclosure.eyes_narrow()
+        self.enclosure.eyes_color(255, 0, 0)
+
+    @intent_handler(IntentBuilder("EnclosureReset")
+                    .require("reset").require("enclosure"))
+    def handle_enclosure_reset(self, message):
+        self.handle_default_eyes()
+        self.enclosure.eyes_reset()
+        self.enclosure.mouth_reset()
+        self.speak("this was fun")
+
+    @intent_handler(IntentBuilder("EnclosureMouthSmile")
+                    .require("smile").one_of("animation", "mouth")
+                    .optionally("enclosure"))
+    def handle_enclosure_smile(self, message):
+        self.enclosure.mouth_smile()
+        self.speak("i don't know how to smile")
+
+    @intent_handler(IntentBuilder("EnclosureMouthListen")
+                    .require("listen").one_of("animation", "mouth")
+                    .optionally("enclosure"))
+    def handle_enclosure_listen(self, message):
+        self.speak("when i do this i feel like I'm dancing")
+        self.enclosure.mouth_listen()
+
+    @intent_handler(IntentBuilder("EnclosureMouthThink")
+                    .require("think").one_of("animation", "mouth")
+                    .optionally("enclosure"))
+    def handle_enclosure_think(self, message):
+        self.speak("i love thinking")
+        self.enclosure.mouth_think()
+
+    @intent_handler(IntentBuilder("EnclosureCrazyEyes")
+                    .require("eyes").optionally("animation").require("crazy")
+                    .optionally("enclosure"))
+    def handle_enclosure_crazy_eyes(self, message):
+        self.speak("artificial intelligence performing artificial "
+                   "stupidity, you don't see this every day")
+        self.play_animation(self.crazy_eyes_animation)
+        self.enclosure.eyes_reset()
+
+    #####################################################################
+    # Color interactions
+    def set_eye_color(self, color=None, rgb=None, speak=True, make_default=False):
+        """ Change the eye color on the faceplate, update saved setting
+        """
+        if color is not None:
+            color_rgb = self._parse_to_rgb(color)
+            if color_rgb is not None:
+                (r, g, b) = color_rgb
+        elif rgb is not None:
+            (r, g, b) = rgb
+        else:
+            return  # no color provided!
+
+        try:
+            self.enclosure.eyes_color(r, g, b)
+            if speak:
+                self.speak_dialog('set.color.success')
+            # Update saved color
+            self.settings['current_eye_color'] = [r, g, b]
+            if make_default:
+                self.settings['default_eye_color'] = [r, g, b]
+        except Exception:
+            self.log.debug('Bad color code: ' + str(color))
+            if speak:
+                self.speak_dialog('error.set.color')
+
+    @intent_handler('custom.eye.color.intent')
+    def handle_custom_eye_color(self, message):
+        # Conversational interaction to set a custom eye color
+
+        def is_byte(utt):
+            try:
+                return 0 <= int(utt) <= 255
+            except Exception:
+                return False
+
+        self.speak_dialog('set.custom.color')
+        wait_while_speaking()
+        r = self.get_response('get.r.value', validator=is_byte,
+                              on_fail="error.rgbvalue", num_retries=2)
+        if not r:
+            return  # cancelled
+
+        g = self.get_response('get.g.value', validator=is_byte,
+                              on_fail="error.rgbvalue", num_retries=2)
+        if not g:
+            return  # cancelled
+
+        b = self.get_response('get.b.value', validator=is_byte,
+                              on_fail="error.rgbvalue", num_retries=2)
+        if not b:
+            return  # cancelled
+
+        custom_rgb = [r, g, b]
+        
+        default = False
+        if self.ask_yesno('set.default.eye.color') == 'yes':
+            default = True
+        self.set_eye_color(rgb=custom_rgb, make_default=default)
+
+    @intent_handler('eye.color.intent')
+    def handle_eye_color(self, message):
+        """ Callback to set eye color from list
+
+            Args:
+                message (dict): messagebus message from intent parser
+        """
+        color_str = (message.data.get('color', None) or
+                     self.get_response('color.need'))
+        if color_str:
+            match = color_from_description(color_str)
+            if match is not None:
+                default = False
+                if self.ask_yesno('set.default.eye.color') == 'yes':
+                    default = True
+                self.set_eye_color(color=match, make_default=default)
+            else:
+                self.speak_dialog('color.not.exist')
+
+    def _parse_to_rgb(self, color):
+        """ Convert color descriptor to RGB
+
+        Parse a color name ('dark blue'), hex ('#000088') or rgb tuple
+        '(0,0,128)' to an RGB tuple.
+
+        Args:
+            color (str): RGB, Hex, or color from color_dict
+        Returns:
+            (r, g, b) (tuple): Tuple of rgb values (0-255) or None
+        """
+        if not color:
+            return None
+
+        # # check if named color is valid
+        try:
+            if isinstance(color, sRGBAColor):
+                if 0 <= color.r <= 255 and 0 <= color.g <= 255 and 0 <= color.b <= 255:
+                    return (color.r, color.g, color.b)
+                else:
+                    return None
+        except Exception:
+            pass
+
+        # check if rgb tuple like '(0,0,128)'
+        try:
+            (r, g, b) = parse_tuple(color)
+            if 0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255:
+                return (r, g, b)
+            else:
+                return None
+        except Exception:
+            pass
+
+        # Finally check if color is hex, like '#0000cc' or '0000cc'
+        return _hex_to_rgb(color)
+
+    def handle_default_eyes(self):
+        if self.settings.get('default_eye_color'):
+            self.set_eye_color(rgb=self.settings['default_eye_color'], speak=False)
+
+    #####################################################################
+    # Brightness intent interaction
+
+    def percent_to_level(self, percent):
+        """ converts the brigtness value from percentage to
+             a value arduino can read
+
+            Args:
+                percent (int): interger value from 0 to 100
+
+            return:
+                (int): value form 0 to 30
+        """
+        return int(float(percent) / float(100) * 30)
+
+    def parse_brightness(self, brightness):
+        """ parse text for brightness percentage
+
+            Args:
+                brightness (str): string containing brightness level
+
+            return:
+                (int): brightness as percentage (0-100)
+        """
+
+        try:
+            if '%' in brightness:
+                brightness = brightness.replace("%", "").strip()
+                return int(brightness)
+            if 'percent' in brightness:
+                brightness = brightness.replace("percent", "").strip()
+                return int(brightness)
+
+            i = int(brightness)
+            if i < 0 or i > 100:
+                return None
+
+            if i < 30:
+                # Assume plain 0-30 is "level"
+                return int((i * 100.0) / 30.0)
+
+            # Assume plain 31-100 is "percentage"
+            return i
+        except Exception:
+            return None  # failed in an int() conversion
+
+    def set_eye_brightness(self, level, speak=True):
+        """ Actually change hardware eye brightness
+
+            Args:
+                level (int): 0-30, brightness level
+                speak (bool): when True, speak a confirmation
+        """
+        self.enclosure.eyes_brightness(level)
+        if speak is True:
+            percent = int(float(level) * float(100) / float(30))
+            self.speak_dialog(
+                'brightness.set', data={'val': str(percent) + '%'})
+
+    def _set_brightness(self, brightness):
+        # brightness can be a number or word like "full", "half"
+        percent = self.parse_brightness(brightness)
+        if percent is None:
+            self.speak_dialog('brightness.not.found.final')
+        elif int(percent) is -1:
+            self.handle_auto_brightness(None)
+        else:
+            self.auto_brightness = False
+            self.set_eye_brightness(self.percent_to_level(percent))
+
+    @intent_handler('brightness.intent')
+    def handle_brightness(self, message):
+        """ Intent Callback to set custom eye colors in rgb
+
+            Args:
+                message (dict): messagebus message from intent parser
+        """
+        brightness = (message.data.get('brightness', None) or
+                      self.get_response('brightness.not.found'))
+        if brightness:
+            self._set_brightness(brightness)
+
+    def stop(self):
+        if self.playing and self.thread is not None:
+            self.playing = False
+            self.enclosure.activate_mouth_events()
+            self.enclosure.eyes_reset()
+            return True
+        return False

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/animation.voc

@@ -0,0 +1,2 @@
+animacions
+animació

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/blink.voc

@@ -0,0 +1 @@
+parpelleja

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.entity

@@ -0,0 +1,13 @@
+#
+##
+###
+#%
+##%
+###%
+complet|ple|plena
+brillant|lluminós
+meitat
+atenuar
+baix
+automàtic|automàtica|automàticament
+automàtic

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.error.dialog

@@ -0,0 +1 @@
+No entenc aquest valor de brillantor, doneu-me un valor de brillantor entre el 0 i el 100 per cent.

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.intent

@@ -0,0 +1,11 @@
+(baixa|aumenta) (la|) (brillantor|il·luminació) al {brightness} (per cent|)
+(canvia a|estableix|commuta) (el|) (nivell|) (de|d'|) (brillantor|il·luminació) dels (ulls|)
+(canvia a|estableix|commuta) els ulls al {brightness} (per cent|) (de|d'|) (brillantor|il·luminació)
+(canvia a|estableix|commuta) els ulls al {brightness} (per cent|) (nivell|) (de|d'|) (brillantor|il·luminació)
+abaixa la (brillantor|il·luminació) dels ulls al {brightness} (per cent|)
+atenua (la|) {brightness} de (els|) ulls al (percentatge|per cent)
+atenua al {brightness} per cent
+enfosqueix|atenua una mica
+ets (massa|) (brillant|oscur)
+il·lumina ho|aumenta la brillantor
+il·lumina-ho (una mica|un poc|) fins al {brightness} (per cent|)

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.levels.value

@@ -0,0 +1,9 @@
+# nom, percentatge
+# NOTA: Afegeix-ho a vocab/xx-xx/brightness.entity, també
+ple, 100
+brillant, 75
+meitat,50
+tènue,25
+feble,10
+auto,-1
+automàtic,-1

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.not.found.dialog

@@ -0,0 +1,2 @@
+Digueu-me un percentatge o un nivell de brillantor per a la meva cara
+Quin nivell o percentatge de brillantor voleu?

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.not.found.final.dialog

@@ -0,0 +1,2 @@
+Ho sento, no entenc aquesta brillantor.
+Només entenc expressions com "ple" o 50%

ovos_skill_mark1_ctrl-0.0.1/locale/ca-ES/brightness.set.dialog

@@ -0,0 +1,2 @@
+D'acord, establint la brillantor a {val}
+Ok, estableixo la brillantor a {val}.