Metadata-Version: 1.1
Name: botanalytics
Version: 0.2.5
Summary: Conversational analytics & engagement tool for chatbots
Home-page: https://github.com/Botanalyticsco/botanalytics-python
Author: Beyhan Esen
Author-email: tech@botanalytics.co
License: MIT
Description: # [Botanalytics](https://botanalytics.co) - Conversational analytics & engagement tool for chatbots
        
        Python SDK currently supports
        
        
        * [Google Assistant](http://docs.botanalytics.apiary.io/)
        * [Amazon Alexa](http://docs.botanalytics.apiary.io/)
        * [Facebook](http://docs.botanalytics.apiary.io/)
        * [Slack](http://docs.botanalytics.apiary.io/)
        * [Generic](http://docs.botanalytics.apiary.io/)
        
        If you want to use nodejs instead, checkout [Botanalytics Node.js SDK](https://github.com/Botanalyticsco/botanalytics)
        
        If you want to use ruby instead, checkout [Botanalytics Ruby SDK](https://github.com/Botanalyticsco/botanalytics-ruby)
        
        ## Setup
        
        Create a free account at [https://www.botanalytics.co](https://www.botanalytics.co) and get a Token.
        
        Botanalytics is available via pip.
        
        ```bash
        pip install botanalytics
        ```
        
        ##### Google Assistant
        ```python
        from botanalytics.google import GoogleAssistant
        from botanalytics.google import GoogleAssistantCloudFunctions
        import os
        
        # Optional callback function, if you specify it, you can handle failed
        #  attemps the way you want
        def err_callback(err, reason, payload):
            pass
        
        # Debug(optional)->bool, token(required)->str,
        # callback(optional)->function, async(optional)-> bool
        botanalytics = GoogleAssistant(
                        debug=True,
                        token=os.environ['BOTANALYTICS_API_TOKEN'],
                        callback=err_callback,
                        async=True
                        )
        # request_payload -> dict, response_payload -> dict
        botanalytics.log(request_payload, response_payload)
        
        # For Google Cloud Functions
        # Debug(optional)->bool, token(required)->str, async(optional)->bool
        botanalytics_gc = GoogleAssistantCloudFunctions(
                            debug=True,
                            token=os.environ['BOTANALYTICS_API_TOKEN'],
                            async=True)
        # request_payload->dict, response_payload->dict
        botanalytics_gc.log(request_payload, response_payload)
        
        ```
        
        ##### Amazon Alexa
        ```python
        from botanalytics.amazon import AmazonAlexa, AmazonAlexaLambda
        import os
        
        # Optional callback function, if you specify it, you can handle failed
        #  attemps the way you want
        def err_callback(err, reason, payload):
            pass
        
        # Debug(optional)->bool, token(required)->str,
        # callback(optional)->function, async(optional)-> bool
        botanalytics = AmazonAlexa(
                            debug=True,
                            token=os.environ['BOTANALYTICS_API_TOKEN'],
                            callback=err_callback,
                            async=True)
        # request_payload -> dict, response_payload -> dict
        botanalytics.log(request_payload, response_payload)
        
        # For lambda
        # Debug(optional)->bool, token(required)->str, async(optional)->bool
        botanalytics_aal = AmazonAlexaLambda(
                                debug=True,
                                token=os.environ['BOTANALYTICS_API_TOKEN'],
                                async=True)
        # request_payload->dict, response_payload->dict
        botanalytics_aal.log(request_payload, response_payload)
        
        ```
        
        ##### Facebook
        ```python
        from botanalytics.facebook import FacebookMessenger
        from http.server import BaseHTTPRequestHandler, HTTPServer
        from urllib.parse import parse_qs
        import requests
        import json
        import os
        
        # Optional callback function, if you specify it, you can handle failed
        #  attemps the way you want
        def err_callback(err, reason, payload):
            pass
        
        botanalytics_token = os.environ['BOTANALYTICS_API_TOKEN']
        fb_page_token = os.environ["FACEBOOK_PAGE_TOKEN"]
        # Debug(optional)->bool, token(required)->str, fb_token(optional)-> str,
        # callback(optional)->function, async(optional)-> bool
        botanalytics = FacebookMessenger(
                                debug=True,
                                token=botanalytics_token,
                                fb_token=fb_page_token,
                                callback=err_callback,
                                async=True
                                )
        
        class BasicRequestHandler(BaseHTTPRequestHandler):
            def __init__(self, *args, **kwargs):
                super(ServerHandler, self).__init__(*args, **kwargs)
        
            def do_POST(self):
                if self.path == '/webhook/facebook':
                    print('Incoming facebook message')
                    self.handle_facebook_message()
                else:
                    # Handle your paths
        
            def handle_facebook_message(self):
                request_body = str(
                        self.rfile.read(
                                int(self.headers['content-length'])
                                ),
                        'utf-8')
                message_payload = json.loads(request_body)
                #log incoming message
                botanalytics.log_incoming(message_payload)
        
                for entry in message_payload['entry']:
                    page_id = entry['id']
                    message_time = entry['time']
                    for event in entry['messaging']:
                        sender_id = event['sender']['id']
                        message_to_build= {}
        
                        #
                        # Handle your event and build your message
                        #
        
                        # log outgoing message
                        botanalytics.log_outgoing(message_to_build, sender_id)
        
                        # send your message
                        response_message = {
                            "recipient": {"id":sender_id},
                            "message": message_to_build,
                        }
                        requests.post(
                            'https://graph.facebook.com/v2.6/me/messages?access_token='+fb_page_token,
                             json = response_message)
        
                self.send_response(200)
        
        def run(server_class=HTTPServer, handler_class=BasicRequestHandler,
                port=8000):
            server_address = ('', port)
            httpd = server_class(server_address, handler_class)
            print('Starting httpd...')
            try:
                httpd.serve_forever()
            except BaseException as ki:
                print(str(ki))
        
        
        if __name__ == "__main__":
            run()
        
        ```
        
        
        ##### Generic
        ```python
        from botanalytics.generic import Generic
        import os
        
        # Optional callback function, if you specify it, you can handle failed
        #  attemps the way you want
        def err_callback(err, reason, payload):
            pass
        
        # Debug(optional)->bool, token(required)->str,
        # callback(optional)->function, async(optional)-> bool
        botanalytics = Generic(
                            debug=True,
                            token=os.environ['BOTANALYTICS_API_TOKEN'],
                            callback=err_callback,
                            async=True)
        # message -> dict
        botanalytics.log(message)
        
        ```
        
        ##### SlackRTMApi
        ```python
        from botanalytics.slack import SlackRTMApi
        from slackclient import SlackClient
        import os
        
        sc = SlackClient(os.environ["SLACK_API_TOKEN"])
        
        # Optional callback function, if you specify it, you can handle failed
        #  attemps the way you want
        def err_callback(err, reason, payload):
            pass
        
        # Debug(optional)->bool, token(required)->str,
        # slack_client_instance(required)-> SlackClient,
        # callback(optional)->function, async(optional)-> bool
        botanalytics = SlackRTMApi(
                             debug=True,
                             token=os.environ['BOTANALYTICS_API_TOKEN'],
                             slack_client_instance=sc, callback=err_callback
                             async=True
                             )
        if sc.rtm_connect():
          while sc.server.connected is True:
                for message in sc.rtm_read():
                    # message -> dict
                    botanalytics.log_incoming(message)
                    # Handle incoming message
                    #       .
                    #       .
                    sc.rtm_send_message("welcome-test", "test")
                    botanalytics.log_outgoing("welcome-test", "test")
                    time.sleep(1)
        else:
            print "Connection Failed"
        
        
        ```
        
        ##### SlackEventApi
        ```python
        from botanalytics.slack import SlackEventApi
        from http.server import BaseHTTPRequestHandler, HTTPServer
        from urllib.parse import parse_qs
        import json
        
        # Optional callback function, if you specify it, you can handle failed
        #  attemps the way you want
        def err_callback(err, reason, payload):
            pass
        
        # Debug(optional)->bool, token(required)->str,
        # slack_token(required)-> str, callback(optional)->function
        # async(optional)-> bool
        botanalytics = SlackEventApi(
                         debug=True,
                         token=os.environ['BOTANALYTICS_API_TOKEN'],
                         slack_token=os.environ["SLACK_API_TOKEN"],
                         callback=err_callback,
                         async=True
                         )
        
        class BasicRequestHandler(BaseHTTPRequestHandler):
            def __init__(self, *args, **kwargs):
                super(ServerHandler, self).__init__(*args, **kwargs)
        
            def do_POST(self):
                if self.path == '/slack/events':
                    print('Incoming event')
                    self.handle_slack_event()
        
                elif self.path == '/slack/interactive':
                    print('Incoming interactive event')
                    self.handle_slack_interactive()
                else:
                    # Handle your paths
        
            def handle_slack_interactive(self):
                byte_dictionary = parse_qs(
                                    self.rfile.read(
                                        int(self.headers['content-length'])),
                                        keep_blank_values=1
                                    )
                interactive_payload = json.loads(
                                        byte_dictionary[b'payload'][0].decode()
                                      )
                botanalytics.log(interactive_payload)
                #
                # Handle interactive payload
                #
                self.send_response(200)
        
            def handle_slack_event(self):
                request_body = str(
                                self.rfile.read(
                                    int(self.headers['content-length'])
                                 ),
                                'utf-8'
                               )
                event_payload = json.loads(request_body)
                botanalytics.log(event_payload)
                #
                #Handle event message
                #
                self.send_response(200)
        
        def run(server_class=HTTPServer, handler_class=BasicRequestHandler,
                        port=8000):
            server_address = ('', port)
            httpd = server_class(server_address, handler_class)
            print('Starting httpd...')
            try:
                httpd.serve_forever()
            except BaseException as ki:
                print(str(ki))
        
        
        if __name__ == "__main__":
            run()
        
        ```
        Follow the instructions at [http://docs.botanalytics.apiary.io/](http://docs.botanalytics.apiary.io/)
        
Keywords: botanalytics bot bots analytics chatbot chatbots conversational facebook google amazon ibm voice actions lex alexa messsenger assistant watson
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
