flowtask 5.8.4__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/interfaces/GoogleGeocoding.py

@@ -0,0 +1,93 @@
+from abc import ABC
+import asyncio
+import googlemaps
+from typing import Tuple, Union, Dict, List
+from .GoogleClient import GoogleClient
+from ..exceptions import ComponentError
+
+
+class GoogleMapsGeocodingClient(GoogleClient, ABC):
+    """
+    Google Maps Geocoding Client for location-based tasks including geocoding, 
+    reverse geocoding, distance calculation, and place details.
+    """
+
+    def __init__(self, *args, api_key: str, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.api_key = api_key
+        self._client = None
+
+    async def get_client(self):
+        """Get the Google Maps client, with caching."""
+        if not self._client:
+            self._client = await asyncio.to_thread(googlemaps.Client, self.api_key)
+        return self._client
+
+    async def geocode_address(self, address: str) -> Dict:
+        """
+        Geocode an address to retrieve latitude and longitude.
+
+        Args:
+            address (str): The address to geocode.
+
+        Returns:
+            dict: Geocoded location with latitude and longitude.
+        """
+        client = await self.get_client()
+        result = await asyncio.to_thread(client.geocode, address)
+        if result:
+            location = result[0]['geometry']['location']
+            return {"lat": location['lat'], "lng": location['lng']}
+        else:
+            raise ComponentError("Address could not be geocoded.")
+
+    async def reverse_geocode(self, lat: float, lng: float) -> List[Dict]:
+        """
+        Reverse geocode coordinates to retrieve address information.
+
+        Args:
+            lat (float): Latitude of the location.
+            lng (float): Longitude of the location.
+
+        Returns:
+            list: List of addresses for the location.
+        """
+        client = await self.get_client()
+        result = await asyncio.to_thread(client.reverse_geocode, (lat, lng))
+        return result
+
+    async def calculate_distance(self, origin: str, destination: str) -> Dict:
+        """
+        Calculate the distance between two locations.
+
+        Args:
+            origin (str): Starting location (address or coordinates).
+            destination (str): Ending location (address or coordinates).
+
+        Returns:
+            dict: Distance and duration between the origin and destination.
+        """
+        client = await self.get_client()
+        result = await asyncio.to_thread(client.distance_matrix, origin, destination)
+        if result['rows']:
+            distance_info = result['rows'][0]['elements'][0]
+            return {
+                "distance": distance_info['distance']['text'],
+                "duration": distance_info['duration']['text']
+            }
+        else:
+            raise ComponentError("Could not calculate distance between locations.")
+
+    async def get_place_details(self, place_id: str) -> Dict:
+        """
+        Get detailed information about a place by its place ID.
+
+        Args:
+            place_id (str): The place ID of the location.
+
+        Returns:
+            dict: Detailed information about the place.
+        """
+        client = await self.get_client()
+        result = await asyncio.to_thread(client.place, place_id)
+        return result['result'] if 'result' in result else {}

flowtask/interfaces/GoogleLang.py

@@ -0,0 +1,114 @@
+from abc import ABC
+import asyncio
+from google.cloud import language_v1
+from google.auth.exceptions import GoogleAuthError
+from .GoogleClient import GoogleClient
+from ..exceptions import ComponentError
+
+
+class GoogleLanguage(GoogleClient, ABC):
+    """
+    Google Cloud Natural Language Client for analyzing text for 
+    sentiment, entities, syntax, and content classification.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._client = None
+
+    async def get_client(self):
+        """Get the Natural Language client, with caching."""
+        if not self._client:
+            try:
+                self._client = await asyncio.to_thread(language_v1.LanguageServiceClient, credentials=self.credentials)
+            except GoogleAuthError as e:
+                raise ComponentError(f"Google Natural Language API authentication error: {e}")
+        return self._client
+
+    async def analyze_sentiment(self, text: str):
+        """
+        Analyze the sentiment of the provided text.
+
+        Args:
+            text (str): The text to analyze.
+
+        Returns:
+            dict: Sentiment score and magnitude.
+        """
+        client = await self.get_client()
+        document = language_v1.Document(content=text, type_=language_v1.Document.Type.PLAIN_TEXT)
+        response = await asyncio.to_thread(client.analyze_sentiment, document=document)
+        sentiment = response.document_sentiment
+        return {"score": sentiment.score, "magnitude": sentiment.magnitude}
+
+    async def analyze_entities(self, text: str):
+        """
+        Analyze entities in the provided text.
+
+        Args:
+            text (str): The text to analyze.
+
+        Returns:
+            list: A list of entities with their types and salience scores.
+        """
+        client = await self.get_client()
+        document = language_v1.Document(content=text, type_=language_v1.Document.Type.PLAIN_TEXT)
+        response = await asyncio.to_thread(client.analyze_entities, document=document)
+        
+        entities = []
+        for entity in response.entities:
+            entities.append({
+                "name": entity.name,
+                "type": language_v1.Entity.Type(entity.type_).name,
+                "salience": entity.salience,
+                "metadata": entity.metadata,
+            })
+        return entities
+
+    async def analyze_syntax(self, text: str):
+        """
+        Analyze syntax of the provided text.
+
+        Args:
+            text (str): The text to analyze.
+
+        Returns:
+            list: A list of tokens with their parts of speech and dependency relationships.
+        """
+        client = await self.get_client()
+        document = language_v1.Document(content=text, type_=language_v1.Document.Type.PLAIN_TEXT)
+        response = await asyncio.to_thread(client.analyze_syntax, document=document)
+        
+        tokens = []
+        for token in response.tokens:
+            tokens.append({
+                "text": token.text.content,
+                "part_of_speech": language_v1.PartOfSpeech.Tag(token.part_of_speech.tag).name,
+                "dependency_edge": {
+                    "head_token_index": token.dependency_edge.head_token_index,
+                    "label": language_v1.DependencyEdge.Label(token.dependency_edge.label).name,
+                }
+            })
+        return tokens
+
+    async def classify_text(self, text: str):
+        """
+        Classify the content of the provided text into categories.
+
+        Args:
+            text (str): The text to classify.
+
+        Returns:
+            list: A list of categories with confidence scores.
+        """
+        client = await self.get_client()
+        document = language_v1.Document(content=text, type_=language_v1.Document.Type.PLAIN_TEXT)
+        response = await asyncio.to_thread(client.classify_text, document=document)
+
+        categories = []
+        for category in response.categories:
+            categories.append({
+                "name": category.name,
+                "confidence": category.confidence,
+            })
+        return categories

flowtask/interfaces/GooglePub.py

@@ -0,0 +1,61 @@
+from google.cloud import pubsub_v1
+from google.auth.exceptions import GoogleAuthError
+import asyncio
+from .GoogleClient import GoogleClient
+from ..exceptions import ComponentError
+
+class GooglePubSubClient(GoogleClient):
+    """
+    Google Pub/Sub Client for managing topics, subscriptions, and message handling.
+    """
+
+    def __init__(self, *args, project_id: str, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.project_id = project_id
+        self._publisher = None
+        self._subscriber = None
+
+    async def get_publisher(self):
+        if not self._publisher:
+            try:
+                self._publisher = await asyncio.to_thread(pubsub_v1.PublisherClient, credentials=self.credentials)
+            except GoogleAuthError as e:
+                raise ComponentError(f"Google Pub/Sub authentication error: {e}")
+        return self._publisher
+
+    async def get_subscriber(self):
+        if not self._subscriber:
+            try:
+                self._subscriber = await asyncio.to_thread(pubsub_v1.SubscriberClient, credentials=self.credentials)
+            except GoogleAuthError as e:
+                raise ComponentError(f"Google Pub/Sub authentication error: {e}")
+        return self._subscriber
+
+    async def create_topic(self, topic_name: str):
+        publisher = await self.get_publisher()
+        topic_path = publisher.topic_path(self.project_id, topic_name)
+        await asyncio.to_thread(publisher.create_topic, name=topic_path)
+        print(f"Topic '{topic_name}' created.")
+
+    async def publish_message(self, topic_name: str, message: str):
+        publisher = await self.get_publisher()
+        topic_path = publisher.topic_path(self.project_id, topic_name)
+        future = await asyncio.to_thread(publisher.publish, topic_path, message.encode("utf-8"))
+        print(f"Published message ID: {future.result()}")
+
+    async def create_subscription(self, topic_name: str, subscription_name: str):
+        subscriber = await self.get_subscriber()
+        topic_path = subscriber.topic_path(self.project_id, topic_name)
+        subscription_path = subscriber.subscription_path(self.project_id, subscription_name)
+        await asyncio.to_thread(subscriber.create_subscription, name=subscription_path, topic=topic_path)
+        print(f"Subscription '{subscription_name}' created for topic '{topic_name}'.")
+
+    async def pull_messages(self, subscription_name: str, max_messages: int = 10):
+        subscriber = await self.get_subscriber()
+        subscription_path = subscriber.subscription_path(self.project_id, subscription_name)
+        response = await asyncio.to_thread(
+            subscriber.pull, request={"subscription": subscription_path, "max_messages": max_messages}
+        )
+        for message in response.received_messages:
+            print(f"Received message: {message.message.data}")
+            await asyncio.to_thread(subscriber.acknowledge, subscription=subscription_path, ack_ids=[message.ack_id])

flowtask/interfaces/GoogleSheet.py

@@ -0,0 +1,68 @@
+from abc import ABC
+from typing import Union
+from pathlib import PurePath, Path
+import pandas as pd
+import asyncio
+from googleapiclient.errors import HttpError
+from .GoogleClient import GoogleClient
+from ..exceptions import ComponentError
+
+
+class GoogleSheetsClient(GoogleClient, ABC):
+    """
+    Google Sheets Client for downloading and interacting with Google Sheets.
+    """
+
+    async def download_file(
+        self,
+        sheet_id: str,
+        worksheet_name: str = None,
+        file_type: str = "dataframe"
+    ) -> Union[pd.DataFrame, str]:
+        """
+        Download the content of a Google Sheet in various formats.
+
+        Args:
+            sheet_id (str): The ID of the Google Sheet.
+            worksheet_name (str): The name of the worksheet (optional, defaults to the first sheet).
+            file_type (str): Desired format - 'dataframe', 'json', 'excel', or 'csv'.
+
+        Returns:
+            pd.DataFrame or str: DataFrame if requested, or the file path for other formats.
+        """
+        try:
+            sheets_service = await asyncio.to_thread(self.get_sheets_client)
+            sheet = await asyncio.to_thread(
+                sheets_service.spreadsheets().get, spreadsheetId=sheet_id
+            )
+            sheet = sheet.execute()
+            sheet_name = worksheet_name or sheet['sheets'][0]['properties']['title']
+
+            # Fetch data as a DataFrame
+            result = await asyncio.to_thread(
+                sheets_service.spreadsheets().values().get,
+                spreadsheetId=sheet_id,
+                range=sheet_name
+            )
+            result = result.execute()
+            values = result.get('values', [])
+            dataframe = pd.DataFrame(values[1:], columns=values[0])  # Assumes first row is the header
+
+            # Format-based handling
+            if file_type == "dataframe":
+                return dataframe
+            elif file_type == "json":
+                return await asyncio.to_thread(dataframe.to_json)
+            elif file_type == "excel":
+                file_path = Path(f"{sheet_name}.xlsx")
+                await asyncio.to_thread(dataframe.to_excel, file_path, index=False)
+                return str(file_path)
+            elif file_type == "csv":
+                file_path = Path(f"{sheet_name}.csv")
+                await asyncio.to_thread(dataframe.to_csv, file_path, index=False)
+                return str(file_path)
+            else:
+                raise ValueError("Invalid file_type. Use 'dataframe', 'json', 'excel', or 'csv'.")
+
+        except HttpError as error:
+            raise ComponentError(f"Error downloading Google Sheet: {error}")

flowtask/interfaces/IMAPClient.py

@@ -0,0 +1,137 @@
+"""
+IMAP/POP Client.
+
+Class for operations with IMAP Mailboxes.
+
+"""
+import socket
+import asyncio
+import ssl
+from collections.abc import Callable
+import imaplib
+from ..exceptions import ComponentError
+from .client import ClientInterface
+from .azureauth import AzureAuth
+
+
+class IMAPClient(ClientInterface):
+    """
+    IMAPClient
+
+    Overview
+
+        The IMAPClient class provides operations for interacting with IMAP mailboxes.
+        It supports both SSL and non-SSL
+        connections and uses XOAUTH2 authentication by default.
+
+    .. table:: Properties
+    :widths: auto
+
+        +------------------+----------+------------------------------------------------------------------------------------------+
+        | Name             | Required | Description                                                                              |
+        +------------------+----------+------------------------------------------------------------------------------------------+
+        | use_ssl          |   No     | Boolean flag to specify whether to use SSL, defaults to True.                            |
+        +------------------+----------+------------------------------------------------------------------------------------------+
+        | mailbox          |   No     | The mailbox to access, defaults to "Inbox".                                              |
+        +------------------+----------+------------------------------------------------------------------------------------------+
+        | overwrite        |   No     | Boolean flag to specify whether to overwrite existing configurations, defaults to False. |
+        +------------------+----------+------------------------------------------------------------------------------------------+
+
+    Return
+
+        The methods in this class manage the connection to the IMAP server and perform authentication and closure of
+        the connection.
+
+    """  # noqa
+
+    _credentials: dict = {"user": str, "password": str}
+    authmech: str = "XOAUTH2"
+    use_ssl = True
+
+    def __init__(
+        self, *args, host: str = None, port: str = None, **kwargs
+    ) -> None:
+        self._connected: bool = False
+        self._client: Callable = None
+        self.use_ssl: bool = kwargs.pop("use_ssl", True)
+        self.mailbox: str = kwargs.pop('mailbox', "Inbox")
+        self.overwrite: bool = kwargs.pop('overwrite', False)
+        self._sslcontext = ssl.create_default_context()
+        self._sslcontext.minimum_version = ssl.TLSVersion.TLSv1_2
+        self._sslcontext.check_hostname = False
+        self._sslcontext.verify_mode = ssl.CERT_NONE
+        self._client: Callable = None
+        self._timeout = kwargs.get('timeout', 20)
+        super(IMAPClient, self).__init__(*args, host=host, port=port, **kwargs)
+        if "use_ssl" in self.credentials:
+            self.use_ssl = self.credentials["use_ssl"]
+            del self.credentials["use_ssl"]
+
+    async def open(self, host: str, port: int, credentials: dict, **kwargs):
+        try:
+            if self.use_ssl:
+                self._client = imaplib.IMAP4_SSL(
+                    host, port, timeout=10, ssl_context=self._sslcontext
+                )
+            else:
+                self._client = imaplib.IMAP4(host, port, timeout=10)
+        except socket.error as e:
+            raise ComponentError(f"Socket Error: {e}") from e
+        except ValueError as ex:
+            print("IMAP err", ex)
+            raise RuntimeError(f"IMAP Invalid parameters or credentials: {ex}") from ex
+        except Exception as ex:
+            print("IMAP err", ex)
+            self._logger.error(
+                f"Error connecting to server: {ex}"
+            )
+            raise ComponentError(
+                f"Error connecting to server: {ex}"
+            ) from ex
+        # start the connection
+        try:
+            # disable debug:
+            self._client.debug = 0
+        except Exception:
+            pass
+        try:
+            await asyncio.sleep(0.5)
+            self._client.timeout = 20
+            if self.authmech is not None:
+                ### we need to build an Auth token:
+                azure = AzureAuth()  # default values
+                result, msg = self._client.authenticate(
+                    self.authmech,
+                    lambda x: azure.binary_token(
+                        credentials["user"], credentials["password"]
+                    ),
+                )
+                print("RESULT ", result, msg)
+                if result == "OK":
+                    self._connected = True
+                    return self._connected
+                else:
+                    raise ComponentError(f"IMAP: Wrong response from Server {msg}")
+            else:
+                # using default authentication
+                r = self._client.login(credentials["user"], credentials["password"])
+                if r.result != "NO":
+                    self._connected = True
+                    return self._connected
+                else:
+                    raise ComponentError(f"IMAP: Wrong response from Server {r.result}")
+        except AttributeError as err:
+            raise ComponentError(
+                f"Login Forbidden, wrong username or password: {err}"
+            ) from err
+        except Exception as err:
+            raise ComponentError(f"Error connecting to server: {err}") from err
+
+    async def close(self, timeout: int = 5):
+        try:
+            if self._client:
+                self._client.close()
+                self._client.logout()
+                self._connected = False
+        except imaplib.IMAP4.abort as err:
+            self._logger.warning(err)

flowtask/interfaces/O365Calendar.py

@@ -0,0 +1,113 @@
+from typing import List, Dict
+from datetime import datetime, timedelta
+from .O365Client import O365Client
+from ..exceptions import ComponentError
+
+
+class OutlookCalendarClient(O365Client):
+    """
+    Outlook Calendar Client for managing calendar events through Microsoft Graph API.
+    """
+
+    async def get_client(self):
+        """Ensure that the Graph client is initialized and ready to use."""
+        if not self._graph_client:
+            self.connection()  # Ensures that `_graph_client` is created during connection setup
+        return self._graph_client
+
+    async def create_event(self, calendar_id: str, event: Dict) -> Dict:
+        """
+        Create an event in the specified Outlook calendar.
+
+        Args:
+            calendar_id (str): The ID of the calendar.
+            event (dict): The event details.
+
+        Returns:
+            dict: Details of the created event.
+        """
+        client = await self.get_client()
+        event = await self.run_in_executor(
+            client.me.calendars[calendar_id].events.add,
+            **event
+        )
+        return event
+
+    async def list_events(
+        self, 
+        calendar_id: str, 
+        start_datetime: datetime, 
+        end_datetime: datetime,
+        max_results: int = 10
+    ) -> List[Dict]:
+        """
+        List events in a specified time range in the specified calendar.
+
+        Args:
+            calendar_id (str): The ID of the calendar.
+            start_datetime (datetime): Start time for retrieving events.
+            end_datetime (datetime): End time for retrieving events.
+            max_results (int): Maximum number of events to retrieve (default: 10).
+
+        Returns:
+            list: List of events in the specified time range.
+        """
+        client = await self.get_client()
+        events = await self.run_in_executor(
+            client.me.calendars[calendar_id].calendar_view,
+            start_datetime.isoformat(),
+            end_datetime.isoformat(),
+            max_results=max_results
+        )
+        return [event.to_dict() for event in events]
+
+    async def get_event(self, calendar_id: str, event_id: str) -> Dict:
+        """
+        Retrieve details of a specific event.
+
+        Args:
+            calendar_id (str): The ID of the calendar.
+            event_id (str): The ID of the event.
+
+        Returns:
+            dict: Details of the retrieved event.
+        """
+        client = await self.get_client()
+        event = await self.run_in_executor(
+            client.me.calendars[calendar_id].events.get,
+            event_id=event_id
+        )
+        return event.to_dict()
+
+    async def update_event(self, calendar_id: str, event_id: str, updated_event: Dict) -> Dict:
+        """
+        Update an existing event in the specified calendar.
+
+        Args:
+            calendar_id (str): The ID of the calendar.
+            event_id (str): The ID of the event.
+            updated_event (dict): Updated event details.
+
+        Returns:
+            dict: Details of the updated event.
+        """
+        client = await self.get_client()
+        updated = await self.run_in_executor(
+            client.me.calendars[calendar_id].events[event_id].update,
+            **updated_event
+        )
+        return updated.to_dict()
+
+    async def delete_event(self, calendar_id: str, event_id: str):
+        """
+        Delete an event from the specified calendar.
+
+        Args:
+            calendar_id (str): The ID of the calendar.
+            event_id (str): The ID of the event to delete.
+        """
+        client = await self.get_client()
+        await self.run_in_executor(
+            client.me.calendars[calendar_id].events[event_id].delete
+        )
+        print(f"Event {event_id} deleted.")