flowtask 5.8.4__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

plugins/components/Workplace.py

@@ -0,0 +1,117 @@
+import pprint
+from asyncdb.utils.types import SafeDict
+from flowtask.components import UserComponent
+from settings.settings import WORKPLACE_ACCESS_TOKEN
+
+class Workplace(UserComponent):
+    _messages_url = 'https://graph.facebook.com/{thread_id}/messages?access_token={access_token}&limit=20&user={member_id}&fields=id,message,created_time,attachments,from,to,tags'
+    _members_url = 'https://graph.facebook.com/community/members?access_token={access_token}&limit=100&fields=member_id,first_name,last_name,name,email,title,organization,division,department,primary_phone,primary_address,picture,link,locale,updated_time,account_invite_time,account_claim_time,account_deactivate_time,external_id,start_date,about,cost_center,work_locale,frontline,active'
+    _member_threads = 'https://graph.facebook.com/{member_id}/conversations/?access_token={access_token}&limit=100&fields=id,name,subject,participants,updated_time,messages'
+    accept = 'application/json'
+
+    async def start(self, **kwargs):
+        ## Access Token
+        if hasattr(self, 'access_token'):
+            access_token = self.access_token
+        else:
+            access_token = WORKPLACE_ACCESS_TOKEN
+        # Workplaces APIs.
+        if self.type == 'messages':
+            self.member_id = self.set_variables(self.member_id)
+            self.thread_id = self.set_variables(self.thread_id)
+            self.messages_url = self._messages_url.format_map(
+                SafeDict(
+                    access_token=access_token,
+                    member_id=self.member_id,
+                    thread_id=self.thread_id,
+                )
+            )
+            self._kwargs = {
+                "url": self.messages_url,
+                "method": "get"
+            }
+        elif self.type == 'members':
+            self.members_url = self._members_url.format_map(SafeDict(access_token=access_token))
+            self._kwargs = {
+                "url": self.members_url,
+                "method": "get"
+            }
+        elif self.type == 'member_threads':
+            self.member_id = self.set_variables(self.member_id)
+            self.member_threads_url = self._member_threads.format_map(
+                SafeDict(access_token=access_token, member_id=self.member_id)
+            )
+            self._kwargs = {
+                "url": self.member_threads_url,
+                "method": "get"
+            }
+
+    async def run(self):
+        results = []
+        result = await self.session(
+            **self._kwargs
+        )
+        if not result:
+            return False
+        if 'data' in result:
+            results += result['data']
+        if 'paging' in result:
+            url = result['paging']['next'] if 'next' in result['paging'] else None
+            while url is not None:
+                self._kwargs['url'] = url
+                resultset = await self.session(
+                    **self._kwargs
+                )
+                results += resultset['data']
+                if 'paging' in result:
+                    url = resultset['paging']['next'] if 'next' in resultset['paging'] else None
+                else:
+                    url = None
+        # Iterate over a field to download more results:
+        if hasattr(self, 'page_over'):
+            columns = self.page_over
+            for row in results:
+                for column in columns:
+                    try:
+                        rw = row[column]
+                    except KeyError:
+                        # there is no messages in this thread
+                        continue
+                    if 'data' in rw:
+                        # replacing "data" with current value of data:
+                        row[column] = row[column]['data']
+                    if 'paging' in row[column]:
+                        url = row[column]['paging']['next'] if 'next' in row[column]['paging'] else None
+                        while url is not None:
+                            resultset = await self.session(
+                                url=url,
+                                method='get'
+                            )
+                            row[column] += resultset['data']
+                            if 'paging' in result:
+                                url = resultset['paging']['next'] if 'next' in resultset['paging'] else None
+                            else:
+                                url = None
+        if hasattr(self, 'flatten_cols'):
+            columns = self.flatten_cols
+            for row in results:
+                for column in columns:
+                    try:
+                        if 'data' in row[column]:
+                            # replacing "data" with current value of data:
+                            row[column] = row[column]['data']
+                    except KeyError:
+                        # there is no column in this thread
+                        continue
+        # Create a Dataframe from Results:
+        self._result = self.create_dataframe(results)
+        if self.type == 'member_threads':
+            # add the value of member_id over all rows:
+            self._result['member_id'] = self.member_id
+        elif self.type == 'messages':
+            self._result['member_id'] = self.member_id
+            self._result['thread_id'] = self.thread_id
+        return self._result
+
+    async def close(self):
+        pass

plugins/components/__init__.py

@@ -0,0 +1,3 @@
+"""
+Directory for saving user-defined components and functions.
+"""

plugins/sources/get_populartimes.py

@@ -0,0 +1,78 @@
+import logging
+import copy
+from querysource.exceptions import *
+from asyncdb.exceptions import NoDataFound
+import populartimes
+import livepopulartimes
+import numpy as np
+from .rest import restSource
+
+def resume_populartimes(data):
+    hours = np.array([data[i]['data'] for i in range(len(data))]).T
+    #visits_by_hour = []{'{}h'.format(str(i)): np.sum(hours[i]) for i in range(len(hours))}
+    visits_by_hour = [{"hour": i,f"{i}h": np.sum(hours[i])} for i in range(len(hours))]
+    visits = [{'day': data[i]['name'].lower(),'{}_total'.format(data[i]['name']).lower() :np.sum(data[i]['data']),'{}_avg'.format(data[i]['name']).lower():np.mean(data[i]['data'])} for i in  range(len(data))]
+    hours = {x['name']:x['data'] for x in data}
+    result = {"visits": visits,"visits_by_hour": visits_by_hour, "hours": hours}
+    # for key,val in cols.items():
+    #     result[key] = val
+    return result
+
+
+class get_populartimes(restSource):
+    """
+      PopularTimes Google API
+        Get populartimes from api
+    """
+    _url = ''
+    _place_id = ''
+
+    def __init__(self, definition=None, params={}, loop=None, env=None):
+        super(get_populartimes, self).__init__(definition, params, loop, env)
+        conditions = copy.deepcopy(params)
+        try:
+            self.type = definition.params['type']
+        except (ValueError, KeyError):
+            self.type = 'get_id'
+
+        try:
+            self.api_key = conditions['api_key']
+            del conditions['api_key']
+        except (ValueError, KeyError):
+            try:
+                self.api_key = definition.params['api_key']
+            except (ValueError, KeyError):
+                raise "PopularTimes: No API KEY defined"
+
+        # Place ID
+        try:
+            self._place_id = conditions['place_id']
+        except (ValueError, KeyError):
+            raise
+
+    async def connect(self):
+        result = None
+        if self.type == 'get_id':
+            try:
+                result = livepopulartimes.get_populartimes_by_PlaceID(self.api_key, self._place_id)
+            except Exception as err:
+                print('ERROR: ', err)
+                return False
+        try:
+            if result:
+                try:
+                    pt = result['populartimes']
+                    popular = resume_populartimes(pt)
+                    result = {
+                        **result,
+                        **popular
+                    }
+                except Exception as err:
+                    print(err)
+                except KeyError:
+                    # store doesnt have PopularTimes
+                    pass
+        except (ValueError, TypeError):
+            raise NoDataFound("PopularTimes Error: Empty Result")
+        finally:
+            return result

plugins/sources/google.py

@@ -0,0 +1,150 @@
+import populartimes
+import livepopulartimes
+import time
+import copy
+from asyncdb.exceptions import ProviderError, NoDataFound
+from querysource.exceptions import DriverError
+from .rest import restSource
+
+
+class google(restSource):
+    """
+      Google API
+        Get all information from Google API (MAPS, geolocation, etc).
+    """
+    method: str = 'GET'
+
+    def __init__(self, definition=None, params: dict = {}, **kwargs):
+        self._place_id = ''
+        super(google, self).__init__(definition, params, **kwargs)
+
+        conditions = copy.deepcopy(params)
+
+        try:
+            self.type = definition.params['type']
+        except (ValueError, KeyError):
+            self.type = None
+
+        if 'type' in params:
+            self.type = params['type']
+            del params['type']
+
+        try:
+            self.api_key = params['api_key']
+            del params['api_key']
+        except (ValueError, KeyError):
+            try:
+                self.api_key = definition.params['api_key']
+            except (ValueError, AttributeError, KeyError):
+                raise "Google: No API KEY defined"
+
+        # get other params
+        conditions['sensor'] = 'false'
+        if self.type == 'textsearch':
+            conditions['query'] = conditions['filter']
+            try:
+                del conditions['filter']
+                del conditions['filterdate']
+                del conditions['refresh']
+                del conditions['place_id']
+            except (KeyError, ValueError, TypeError):
+                pass
+            try:
+                conditions['type'] = definition.params['store_type']
+            except (KeyError, ValueError, TypeError):
+                pass
+            self.url = 'https://maps.googleapis.com/maps/api/place/textsearch/json'
+        elif self.type == 'place_details':
+            # Place ID
+            if not 'place_id' in conditions and 'placeid' in conditions:
+                conditions['place_id'] = conditions['placeid']
+            try:
+                self._place_id = conditions['place_id']
+            except (ValueError, KeyError):
+                raise
+            try:
+                del conditions['filter']
+                del conditions['placeid']
+            except (KeyError, ValueError, TypeError):
+                pass
+            self.url = 'https://maps.googleapis.com/maps/api/place/details/json'
+        elif self.type == 'nearby':
+            conditions['query'] = conditions['filter']
+            try:
+                del conditions['filter']
+                del conditions['filterdate']
+                del conditions['refresh']
+            except (KeyError, ValueError, TypeError):
+                pass
+            try:
+                conditions['location'] = "{},{}".format(conditions['lat'], conditions['lng'])
+                del conditions['lng']
+                del conditions['lat']
+            except (KeyError, ValueError, TypeError):
+                pass
+            try:
+                conditions['radius'] = conditions['radius']
+            except (KeyError, ValueError, TypeError):
+                conditions['radius'] = 10000
+            self.url = 'https://maps.googleapis.com/maps/api/place/textsearch/json'
+        try:
+            if conditions['required_fields']:
+                conditions['fields'] = conditions['required_fields']
+            del conditions['required_fields']
+        except (KeyError, ValueError, TypeError):
+            pass
+        try:
+            if definition.params['store_type']:
+                conditions['type'] = definition.params['store_type']
+        except (KeyError, ValueError, TypeError):
+            pass
+        # API key
+        conditions['key'] = self.api_key
+        self._params = conditions
+
+        # create URL
+        #self._url = self.build_url(self._url, args = None, queryparams = urlencode(conditions))
+
+    async def get_next_result(self, result):
+        r = []
+        token = result['next_page_token']
+        time.sleep(3)
+        if self.type == 'textsearch':
+            url = 'https://maps.googleapis.com/maps/api/place/textsearch/json?pagetoken={token}&key={key}'.format(token=token,key=self.api_key)
+        elif self.type == 'nearby':
+            url = 'https://maps.googleapis.com/maps/api/place/textsearch/json?pagetoken={token}&key={key}'.format(token=token,key=self.api_key)
+        try:
+            r = await self.request(url)
+            if r["status"] and r["status"] == "OK":
+                return r
+            else:
+                return []
+        except Exception as err:
+            print(err)
+            return []
+
+
+    async def query(self, url: str = None, params: dict = {}):
+        result = await super(google, self).query(url, params)
+        resultset = None
+        try:
+            if self.type == 'textsearch' or self.type == 'nearby':
+                resultset = result['results']
+                # TODO build the iteration based on next page token
+                try:
+                    #TODO making recursive queries
+                    if result['next_page_token']:
+                        r = await self.get_next_result(result)
+                        resultset = [*resultset, *r["results"]]
+                        if r['next_page_token']:
+                            r = await self.get_next_result(r)
+                            resultset = [*resultset, *r["results"]]
+                except(KeyError, ValueError):
+                    pass
+                result = resultset
+            elif self.type == 'place_details':
+                result = result['result']
+        except Exception as err:
+            raise NoDataFound(f"Google Error: {err!s}")
+        finally:
+            return result