Upload 24 files

Readme.md

@@ -0,0 +1,126 @@
+# Flowify - Workflow Automation Platform
+
+Flowify is a powerful automation platform that enables users to create custom workflows through a visual interface and deploy them as APIs. Whether you're managing personal tasks or streamlining business processes, Flowify helps you automate repetitive tasks and focus on what matters most.
+
+## 🌟 Features
+
+### Visual Workflow Builder
+- Drag-and-drop interface for creating workflows
+- Real-time workflow visualization
+- Connect nodes with intuitive linking
+- Zoom and pan controls for large workflows
+
+### Node Types
+1. **Scraping Nodes**
+   - HTML content extraction
+   - Image URL extraction
+   - Link extraction with filtering
+   - Table data extraction
+   - Header extraction
+   - Metadata extraction
+   - JavaScript/CSS file URL extraction
+   - Targeted div content extraction
+
+2. **Social Media Nodes**
+   - X (Twitter) integration
+   - Reddit posting
+   - Social media analytics
+
+3. **AI Nodes**
+   - AI response generation
+   - Custom prompt handling
+
+4. **Array Manipulation Nodes**
+   - List creation and management
+   - Element extraction
+   - Array operations
+
+### Additional Features
+- Dark/Light mode support
+- Responsive design
+- API endpoint generation
+- Workflow scheduling
+- Real-time execution monitoring
+
+## 🚀 Getting Started
+
+1. **Create an Account**
+   - Visit the registration page
+   - Set up your credentials
+   - Choose your plan
+
+2. **Create Your First Workflow**
+   - Navigate to the Dashboard
+   - Click "Create Workflow"
+   - Add and connect nodes
+   - Configure node settings
+   - Save and deploy
+
+3. **Access Your Workflow**
+   - Get your unique API endpoint
+   - Integrate with your applications
+   - Monitor execution results
+
+## 💻 Technical Details
+
+### API Usage
+Each workflow can be accessed through a unique API endpoint. The endpoint URL is provided in the workflow settings page after deployment.
+
+### Node Configuration
+Nodes can be configured with various parameters:
+- Input/output settings
+- Authentication credentials
+- Filtering options
+- Scheduling parameters
+
+### Security
+- Secure API authentication
+- Encrypted credential storage
+- Rate limiting protection
+- User-specific workflow isolation
+
+## 📊 Plans and Pricing
+
+### Free Plan
+- Up to 3 active workflows
+- Basic scheduling (once per day)
+- 1,000 API requests/month
+- Core workflow builder access
+
+### Silver Plan
+- Up to 10 active workflows
+- Hourly scheduling
+- 10,000 API requests/month
+- Advanced workflow builder tools
+
+### Gold Plan
+- Unlimited active workflows
+- Real-time triggers
+- Unlimited API usage
+- Webhook support and custom scripts
+
+## 🤝 Contributing
+
+We welcome contributions to Flowify! Please read our contributing guidelines before submitting pull requests.
+
+## 📄 License
+
+Flowify is licensed under the [MIT License](LICENSE).
+
+## 📞 Support
+
+Need help? Contact us:
+- Documentation: [docs.flowify.com](https://docs.flowify.com)
+- Email: [email protected]
+- GitHub Issues: [Report a bug](https://github.com/flowify/issues)
+
+## 🌐 Links
+
+- [Website](https://flowify.com)
+- [Documentation](https://docs.flowify.com)
+- [Blog](https://blog.flowify.com)
+- [API Reference](https://api.flowify.com)
+
+---
+
+Made with ❤️ by the Flowify Team

app.py

@@ -0,0 +1,27 @@
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from executor.workflow import execute
+import pyrebase
+
+app = FastAPI()
+
+# Enable CORS for all origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def index():
+    return {"message": "Welcome to the Flowify Workflow Executor API"}
+
+@app.post("/execute")
+async def execute_workflow(request: Request):
+    workflow = await request.json()  
+    print(workflow)
+    data = execute(workflow)
+    return data 
+

executor/workflow.py

@@ -0,0 +1,210 @@
+from nodes.scraping.html import *
+from nodes.llm.textmodel import ai_response as generate_ai_response
+from nodes.socialmedia.x import *
+from nodes.socialmedia.reddit import reddit_post
+from nodes.processing.list import *
+
+#updating the executor to process multiple nodes for better execution (Mon jan 6 2025)
+def execute(workflow):
+
+    print(workflow)
+
+    # Nodes that do not depend on any other node for input
+    unique_node = []
+
+    # Nodes that depend on other nodes for input
+    dependant_node = []
+    
+    # Temporary storage for saving the output of the nodes
+    temp_data = []
+
+    # Assigning unique or dependent nodes to their respective array
+    for step in workflow['steps']:
+        # Check if 'config' contains a reference to other nodes
+        is_dependant = False
+        if 'config' in step and isinstance(step['config'], dict):
+            for key, value in step['config'].items():
+                # If the value contains a reference like 'node-1', 'node-2', etc.
+                if isinstance(value, str) and value.startswith('node-'):
+                    is_dependant = True
+                    break
+
+        if is_dependant:
+            dependant_node.append(step)
+        else:
+            unique_node.append(step)
+
+    for step in workflow['steps']:
+        print("executing step", step['node'], step['type'])
+
+        if step['type'] == "scrape_html":
+            for temp in temp_data:
+                if temp['node'] == step['config']['url']:
+                    print(temp['data'])
+                    data = scrape_html(temp['data'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                data = scrape_html(step['config']['url'])
+                temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+
+        elif step['type'] == "scrape_images":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    filter = step['config']['filter']
+                    data = scrape_images(data=temp['data'], filter=filter)
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                    data = step['config']['data']
+                    filter = step['config']['filter']
+                    response = scrape_images(data=data, filter=filter)
+                    temp_data.append({'node': step['node'], 'data': response, 'type':step['type']})
+                
+        elif step['type'] == "scrape_links":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    data = scrape_links(url = temp['data'], filter=step['config']['filter'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                data = scrape_links(url = step['config']['data'], filter=step['config']['filter'])
+                temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                
+        elif step['type'] == "scrape_metadata":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    data = scrape_text(temp['data'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                    data = step['config']['data']
+                    scrape_text(data)
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                
+        elif step['type'] == "scrape_text":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    data = scrape_text(str(temp['data']))
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                    data = step['config']['data']
+                    scrape_text(data)
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    
+        elif step['type'] == "create_tweet":
+            for temp in temp_data:
+                print("node", temp['node'])
+                if temp['node'] == step['config']['data']:
+                    print('foudntemp node')
+                    login = step['config']['login']
+                    data = create_tweet(text=temp['data'], login=login)
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                print('not found node')
+                data = step['config']['data']
+                login = step['config']['login']
+                data = create_tweet(text=data, login=login)
+                temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+
+        elif step['type'] == "create_reddit":
+            for temp in temp_data:
+                print("node", temp['node'])
+                if temp['node'] == step['config']['data']:
+                    print('foud temp node')
+                    username = step['config']['username']
+                    password = step['config']['password']
+                    subreddit = step['config']['subreddit']
+                    client_id = step['config']['id']
+                    client_secret = step['config']['secret']
+                    title = step['config']['secret']
+                    data = reddit_post(client_id, client_secret, username, password, subreddit, title, body=temp['data'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                username = step['config']['username']
+                password = step['config']['password']
+                subreddit = step['config']['subreddit']
+                client_id = step['config']['id']
+                client_secret = step['config']['secret']
+                title = step['config']['secret']
+                data = reddit_post(client_id, client_secret, username, password, subreddit, title, body=step['config']['data'])
+                temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                
+        elif step["type"] == "ai_response":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    data = generate_ai_response(step['config']['prompt'] + str(temp['data']))
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                    data = generate_ai_response(prompt=step['config']['prompt'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    
+        
+        elif step['type'] == "scrape_div":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    data = scrape_div(data=temp['data'], div=step['config']['class'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                    data = step['config']['data']
+                    class_ = step['config']['class']
+                    data = scrape_div(data=data, div=class_)
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    
+
+        elif step['type'] == "extract_element":
+            for temp in temp_data:
+                if temp['node'] == step['config']['data']:
+                    print(step['config']['data'])
+                    data = extract_element(list_=temp['data'], index=step['config']['index'], value=step['config']['value'])
+                    temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                    break
+            else:
+                data = extract_element(list_=step['config']['data'], index=step['config']['index'], value=step['config']['value'])
+                temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+                
+        
+        elif step['type'] == "create_list":
+            data = step['config']['data']
+            # Convert string representation of list to actual list
+            if isinstance(data, str):
+                try:
+                    data = eval(data)
+                except:
+                    pass
+            temp_data.append({'node': step['node'], 'data': data, 'type':step['type']})
+
+        elif step['type'] == "reddit_post":
+            title = step['config']['title']
+            content = step['config']['data']
+            
+            # Check if title is from another node
+            for temp in temp_data:
+                if temp['node'] == title:
+                    title = temp['data']
+                    break
+            
+            # Check if content is from another node
+            for temp in temp_data:
+                if temp['node'] == content:
+                    content = temp['data']
+                    break
+            
+            data = reddit_post(
+                client_id=step['config']['client_id'],
+                client_secret=step['config']['client_secret'],
+                username=step['config']['username'],
+                password=step['config']['password'],
+                subreddit=step['config']['subreddit'],
+                title=title,
+                body=content
+            )
+            temp_data.append({'node': step['node'], 'data': data, 'type': step['type']})
+
+    return temp_data
+

nodes/llm/textmodel.py

@@ -0,0 +1,103 @@
+from typing import Union, Dict
+import requests
+from tenacity import retry, stop_after_attempt, wait_exponential
+import time
+import json
+
+class AIResponseError(Exception):
+    """Custom exception for AI response errors"""
+    pass
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+    reraise=True
+)
+def ai_response(prompt: str) -> Union[str, Dict[str, str]]:
+    cookies = {
+    'intercom-id-evnv2y8k': 'fea4d452-f9be-42e0-93e3-1e47a3836362',
+    'intercom-device-id-evnv2y8k': '2bb3e469-0159-4b6b-a33e-1aea4b51ccb1',
+    '__stripe_mid': 'e0f7c1ba-56c6-44d4-ba1d-cf4611453eb43cf922',
+    'state-csrf': 'z4pfq6gvoqmg92gkq6bljm',
+    'together_auth_cookie': '%7B%22expires%22%3A%222026-03-11T14%3A02%3A04.928Z%22%2C%22session%22%3A%22b672ad1b7784bcbb96a5b43058d3d4fbd8327f32dd020f12664307eed353c1b86f1e0d515a4c8b2d990dc5017ed1f13cd7514dee6263bcbd9e03446143245ba0c21968f273967cdb73dd6fedb0a9ff2b65a3ed2ce66b2cd4f94053c747be019d93327fa1f6b24bca9a559ba98ec48f2b51c3be242891d86bb670453120eed64e%22%7D',
+    'AMP_MKTG_7112ee0414': 'JTdCJTIycmVmZXJyZXIlMjIlM0ElMjJodHRwcyUzQSUyRiUyRmFjY291bnRzLmdvb2dsZS5jb20lMkYlMjIlMkMlMjJyZWZlcnJpbmdfZG9tYWluJTIyJTNBJTIyYWNjb3VudHMuZ29vZ2xlLmNvbSUyMiU3RA==',
+    'intercom-session-evnv2y8k': 'UWtNaFEraEJ3ZzcydXlwUC94MHhPcGg3eGZ6RXJkM2c3a2J3R1dwUGR4RWRzQnozWFNLQ0tqbW5za0gvU3RodmNZNXh4NVhRL3I5RWhwNjZKRnd5M21XRm9sZUZhTm05ZUUvaXMxZEYrNjQ9LS1OS0dDcFpuZGRCRE5XaWkxcDVZOEtBPT0=--83289f02195d8a45658bb26d7036c1bf9cfe9887',
+    '__stripe_sid': '7e7f0bab-efaa-4ec6-ae34-2857cccc4f644bc033',
+        'AMP_7112ee0414': 'JTdCJTIyZGV2aWNlSWQlMjIlM0ElMjI5NGU0MzFjOS02OTM0LTQwMGItYTk3Ni0yZjEyNzZmNjg4YzklMjIlMkMlMjJ1c2VySWQlMjIlM0ElMjI2N2I4M2E1Y2Q4MzFiZTcxYjAyYjM4MmElMjIlMkMlMjJzZXNzaW9uSWQlMjIlM0ExNzQxNzAxNzE5MDE5JTJDJTIyb3B0T3V0JTIyJTNBZmFsc2UlMkMlMjJsYXN0RXZlbnRUaW1lJTIyJTNBMTc0MTcwMTc1NTU4MSUyQyUyMmxhc3RFdmVudElkJTIyJTNBODklMkMlMjJwYWdlQ291bnRlciUyMiUzQTQlN0Q=',
+    }
+
+    headers = {
+        'accept': '*/*',
+        'accept-language': 'en-US,en;q=0.9,ja;q=0.8',
+        'authorization': 'Bearer bb80c2632e2d0ee9c8b5208fcfca771159cf0fd8f9b06404c9f2103ca936310e',
+        'content-type': 'application/json',
+        'origin': 'https://api.together.ai',
+        'priority': 'u=1, i',
+        'referer': 'https://api.together.ai/playground/chat/meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo',
+        'sec-ch-ua': '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"macOS"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-site': 'same-origin',
+        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+        # 'cookie': 'intercom-id-evnv2y8k=fea4d452-f9be-42e0-93e3-1e47a3836362; intercom-device-id-evnv2y8k=2bb3e469-0159-4b6b-a33e-1aea4b51ccb1; __stripe_mid=e0f7c1ba-56c6-44d4-ba1d-cf4611453eb43cf922; state-csrf=z4pfq6gvoqmg92gkq6bljm; together_auth_cookie=%7B%22expires%22%3A%222026-03-11T14%3A02%3A04.928Z%22%2C%22session%22%3A%22b672ad1b7784bcbb96a5b43058d3d4fbd8327f32dd020f12664307eed353c1b86f1e0d515a4c8b2d990dc5017ed1f13cd7514dee6263bcbd9e03446143245ba0c21968f273967cdb73dd6fedb0a9ff2b65a3ed2ce66b2cd4f94053c747be019d93327fa1f6b24bca9a559ba98ec48f2b51c3be242891d86bb670453120eed64e%22%7D; AMP_MKTG_7112ee0414=JTdCJTIycmVmZXJyZXIlMjIlM0ElMjJodHRwcyUzQSUyRiUyRmFjY291bnRzLmdvb2dsZS5jb20lMkYlMjIlMkMlMjJyZWZlcnJpbmdfZG9tYWluJTIyJTNBJTIyYWNjb3VudHMuZ29vZ2xlLmNvbSUyMiU3RA==; intercom-session-evnv2y8k=UWtNaFEraEJ3ZzcydXlwUC94MHhPcGg3eGZ6RXJkM2c3a2J3R1dwUGR4RWRzQnozWFNLQ0tqbW5za0gvU3RodmNZNXh4NVhRL3I5RWhwNjZKRnd5M21XRm9sZUZhTm05ZUUvaXMxZEYrNjQ9LS1OS0dDcFpuZGRCRE5XaWkxcDVZOEtBPT0=--83289f02195d8a45658bb26d7036c1bf9cfe9887; __stripe_sid=7e7f0bab-efaa-4ec6-ae34-2857cccc4f644bc033; AMP_7112ee0414=JTdCJTIyZGV2aWNlSWQlMjIlM0ElMjI5NGU0MzFjOS02OTM0LTQwMGItYTk3Ni0yZjEyNzZmNjg4YzklMjIlMkMlMjJ1c2VySWQlMjIlM0ElMjI2N2I4M2E1Y2Q4MzFiZTcxYjAyYjM4MmElMjIlMkMlMjJzZXNzaW9uSWQlMjIlM0ExNzQxNzAxNzE5MDE5JTJDJTIyb3B0T3V0JTIyJTNBZmFsc2UlMkMlMjJsYXN0RXZlbnRUaW1lJTIyJTNBMTc0MTcwMTc1NTU4MSUyQyUyMmxhc3RFdmVudElkJTIyJTNBODklMkMlMjJwYWdlQ291bnRlciUyMiUzQTQlN0Q=',
+    }
+    model = 'meta-llama/Llama-Vision-Free'
+
+    current_messages = []
+
+    current_messages.append({
+            'content': [{
+                'type': 'text',
+                'text': prompt
+            }],
+            'role': 'user'
+        })
+
+    json_data = {
+        'model': model,
+        'max_tokens': None,
+        'temperature': 0.7,
+        'top_p': 0.7,
+        'top_k': 50,
+        'repetition_penalty': 1,
+        'stream_tokens': True,
+        'stop': ['<|eot_id|>', '<|eom_id|>'],
+        'messages': current_messages,
+        'stream': True,
+    }
+
+    response_text = ""
+    max_retries = 5
+    base_delay = 1  # Initial delay in seconds
+    
+    for attempt in range(max_retries):
+        response = requests.post('https://api.together.ai/inference', cookies=cookies, headers=headers, json=json_data, stream=True)
+        
+        if response.status_code == 200:
+            for line in response.iter_lines():
+                if line:
+                    decoded_line = line.decode('utf-8')
+                    if decoded_line.startswith('data: '):
+                        data = decoded_line[6:]  # Remove 'data: ' prefix
+                        if data == '[DONE]':
+                            return response_text
+                        try:
+                            json_response = json.loads(data)
+                            if 'choices' in json_response and json_response['choices']:
+                                text = json_response['choices'][0].get('text', '')
+                                response_text += text
+                        except json.JSONDecodeError:
+                            continue
+            return response_text
+        elif response.status_code == 429:
+            if attempt < max_retries - 1:
+                time.sleep(0.5)
+                continue
+            raise AIResponseError("Rate limited, maximum retries reached")
+        else:
+            raise AIResponseError(f"Unexpected status code: {response.status_code}")
+    
+    raise AIResponseError("Maximum retries reached")
+    

nodes/processing/list.py

@@ -0,0 +1,36 @@
+import random
+
+def extract_element(index, list_, value):
+    try:
+        if value == "false":
+            if index == "random":
+                data = random.choice(list_)
+                return data
+            else:
+                data = list_[int(index)]
+                return data
+        else:
+            if index == "random":
+                data = random.choice(list_)
+                return data[0] if isinstance(data, list) else data
+            else:
+                data = list_[int(index)]
+                return data[0] if isinstance(data, list) else data
+    except Exception as e:
+        raise ValueError(f"Error extracting element: {e}")
+
+def extract_data(name, list_):
+    try:
+        data = list_[name]
+        return data
+    except Exception as e:
+        raise ValueError(f"Error extracting data: {e}")
+
+def create_list(list_):
+    try:
+        data = []
+        for ele in list_:
+            data.append(ele)
+            return data
+    except Exception as e:
+        raise ValueError(f"Error creating list: {e}")

nodes/processing/requests.py

@@ -0,0 +1,45 @@
+from curl_cffi import requests as curl_requests
+import json
+
+def custom_requests(url, method='GET', res_type='json', kwargs=None):
+    """
+    Make a custom HTTP request
+    
+    Args:
+        url (str): The URL to make the request to
+        method (str): HTTP method (GET, POST, PUT, DELETE)
+        res_type (str): Response type (json or text)
+        kwargs (dict): Additional arguments for the request (headers, body, etc.)
+    
+    Returns:
+        dict/str: Response data based on res_type
+    """
+    try:
+        # Parse kwargs if it's a string
+        if isinstance(kwargs, str):
+            kwargs = json.loads(kwargs)
+        elif kwargs is None:
+            kwargs = {}
+
+        # Make the request
+        response = curl_requests.request(
+            method=method.upper(),
+            url=url,
+            **kwargs,
+            impersonate='chrome101'
+        )
+        
+        # Raise for bad status
+        response.raise_for_status()
+        
+        # Return based on response type
+        if res_type.lower() == 'json':
+            return response.json()
+        else:
+            return response.text
+            
+    except curl_requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON in response"}
+

nodes/scraping/html.py

@@ -0,0 +1,249 @@
+from curl_cffi import requests as req
+from bs4 import BeautifulSoup
+import logging
+from typing import Union, List, Dict, Optional
+from urllib.parse import urljoin, urlparse
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ScrapingError(Exception):
+    """Custom exception for scraping errors"""
+    pass
+
+def validate_url(url: str) -> bool:
+    """Validate if the given URL is properly formatted"""
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except Exception:
+        return False
+
+def clean_url(url: str) -> str:
+    """Clean and normalize URL"""
+    if url.startswith('//'):
+        return f'https:{url}'
+    return url
+
+def scrape_html(url: str) -> Union[str, Dict[str, str]]:
+    """
+    Fetch HTML content from a URL with improved error handling
+    
+    Args:
+        url (str): The URL to scrape
+        
+    Returns:
+        str: HTML content if successful
+        dict: Error information if failed
+    """
+    try:
+        if not validate_url(url):
+            return {"error": "Invalid URL format"}
+
+        response = req.get(
+            url, 
+            impersonate='chrome110',
+            timeout=30,
+            max_redirects=5
+        )
+        
+        # Check if response is HTML
+        content_type = response.headers.get('content-type', '').lower()
+        if 'text/html' not in content_type:
+            return {"error": f"Unexpected content type: {content_type}"}
+
+        return response.text
+    
+    except Exception as e:
+        logger.error(f"Unexpected error while scraping {url}: {str(e)}")
+        return {"error": f"Unexpected error: {str(e)}"}
+
+def scrape_images(data: str, filter: str = "") -> Union[List[str], Dict[str, str]]:
+    """
+    Extract image URLs from HTML content with improved filtering and validation
+    
+    Args:
+        data (str): HTML content
+        filter (str): Optional filter string for URLs
+        
+    Returns:
+        list: List of image URLs if successful
+        dict: Error information if failed
+    """
+    try:
+        if not data:
+            return {"error": "No HTML content provided"}
+
+        soup = BeautifulSoup(data, 'html.parser')
+        images = []
+        
+        # Look for both img tags and background images in style attributes
+        for img in soup.find_all('img'):
+            src = img.get('src') or img.get('data-src')
+            if src:
+                src = clean_url(src)
+                if validate_url(src) and (not filter or filter.lower() in src.lower()):
+                    images.append(src)
+
+        # Look for background images in style attributes
+        for elem in soup.find_all(style=True):
+            style = elem['style']
+            if 'background-image' in style:
+                url_start = style.find('url(') + 4
+                url_end = style.find(')', url_start)
+                if url_start > 4 and url_end != -1:
+                    src = style[url_start:url_end].strip('"\'')
+                    src = clean_url(src)
+                    if validate_url(src) and (not filter or filter.lower() in src.lower()):
+                        images.append(src)
+
+        return list(set(images))  # Remove duplicates
+
+    except Exception as e:
+        logger.error(f"Error extracting images: {str(e)}")
+        return {"error": f"Failed to extract images: {str(e)}"}
+
+def scrape_links(url: str, filter: str = "") -> Union[List[str], Dict[str, str]]:
+    """
+    Extract links from a webpage with improved validation and error handling
+    
+    Args:
+        url (str): URL to scrape
+        filter (str): Optional filter for links
+        
+    Returns:
+        list: List of links if successful
+        dict: Error information if failed
+    """
+    try:
+        if not validate_url(url):
+            return {"error": "Invalid URL format"}
+
+
+        print(url)
+        response = req.get(url, impersonate='chrome110')
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+        links = []
+        base_url = url
+
+        try:
+
+            for a in soup.find_all('a', href=True):
+                href = a['href']
+                # Convert relative URLs to absolute
+                full_url = urljoin(base_url, href)
+                
+                if validate_url(full_url) and (not filter or filter.lower() in full_url.lower()):
+                    links.append(full_url)
+
+            return list(set(links))  # Remove duplicates
+        
+        except Exception as e:
+            logger.error(f"Error processing links: {str(e)}")
+            return {"error": f"Failed to process links: {str(e)}"}
+
+    except Exception as e:
+        logger.error(f"Error extracting links: {str(e)}")
+        return {"error": f"Failed to extract links: {str(e)}"}
+
+def scrape_text(data: str) -> Union[str, Dict[str, str]]:
+    """
+    Extract clean text content from HTML
+    
+    Args:
+        data (str): HTML content
+        
+    Returns:
+        str: Extracted text if successful
+        dict: Error information if failed
+    """
+    try:
+        if not data:
+            return {"error": "No HTML content provided"}
+
+        soup = BeautifulSoup(data, 'html.parser')
+        
+        # Remove script and style elements
+        for element in soup(['script', 'style', 'head']):
+            element.decompose()
+        
+        # Get text and clean it
+        text = soup.get_text(separator='\n')
+        # Remove excessive newlines and whitespace
+        text = '\n'.join(line.strip() for line in text.split('\n') if line.strip())
+        
+        return text
+
+    except Exception as e:
+        logger.error(f"Error extracting text: {str(e)}")
+        return {"error": f"Failed to extract text: {str(e)}"}
+
+def scrape_div(data: str, div: str) -> Union[List[str], Dict[str, str]]:
+    """
+    Extract content from specific div elements
+    
+    Args:
+        data (str): HTML content
+        div (str): Class or ID of the div to scrape
+        
+    Returns:
+        list: List of div contents if successful
+        dict: Error information if failed
+    """
+    try:
+        if not data:
+            return {"error": "No HTML content provided"}
+        if not div:
+            return {"error": "No div selector provided"}
+
+        soup = BeautifulSoup(data, 'html.parser')
+        results = []
+
+        # Try class first
+        elements = soup.find_all(class_=div)
+        if not elements:
+            # Try ID if no class found
+            elements = soup.find_all(id=div)
+            if not elements:
+                return {"error": f"No elements found with class or ID: {div}"}
+
+        for element in elements:
+            # Get both text and HTML content
+            content = {
+                "text": element.get_text(strip=True),
+                "html": str(element)
+            }
+            results.append(content)
+
+        return results
+
+    except Exception as e:
+        logger.error(f"Error extracting div content: {str(e)}")
+        return {"error": f"Failed to extract div content: {str(e)}"}
+
+# Function to scrape metadata
+def scrape_metadata(data):
+    soup = BeautifulSoup(data, 'html.parser')
+    metadata = {}
+    for meta in soup.find_all('meta'):
+        name = meta.get('name') or meta.get('property')
+        content = meta.get('content')
+        if name and content:
+            metadata[name] = content
+    return metadata
+
+# Function to scrape table data
+def scrape_tables(data):
+    soup = BeautifulSoup(data, 'html.parser')
+    tables = []
+    for table in soup.find_all('table'):
+        rows = []
+        for row in table.find_all('tr'):
+            cells = [cell.get_text(strip=True) for cell in row.find_all(['th', 'td'])]
+            rows.append(cells)
+        tables.append(rows)
+    return tables
+
+

nodes/socialmedia/instagram.py

@@ -0,0 +1,9 @@
+import instabot
+
+def insta_post(username, password, caption, image):
+    bot = instabot.Bot()
+    bot.login(username=username, password=password)
+    bot.upload_photo(image, caption=caption)
+    bot.logout()
+
+

nodes/socialmedia/reddit.py

@@ -0,0 +1,106 @@
+import logging
+from typing import Union, Dict
+import praw
+import random
+import string
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class RedditError(Exception):
+    """Custom exception for Reddit API errors"""
+    pass
+
+def validate_reddit_credentials(client_id: str, client_secret: str, username: str, password: str) -> bool:
+    """Validate Reddit credentials"""
+    return all([client_id, client_secret, username, password])
+
+def generate_random_user_agent():
+    """Generate a random user agent."""
+    prefix = "my_script_by_u/"
+    username = "your_reddit_username"  # Replace with your Reddit username
+    random_suffix = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+    return f"{prefix}{username}_{random_suffix}"
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+    reraise=True
+)
+def reddit_post(
+    client_id: str,
+    client_secret: str,
+    username: str,
+    password: str,
+    subreddit: str,
+    title: str,
+    body: str = ""
+) -> Union[Dict[str, str], Dict[str, str]]:
+    """
+    Create a Reddit post with improved error handling and retries
+    
+    Args:
+        client_id (str): Reddit API client ID
+        client_secret (str): Reddit API client secret
+        username (str): Reddit username
+        password (str): Reddit password
+        subreddit (str): Target subreddit
+        title (str): Post title
+        body (str): Post content
+        
+    Returns:
+        dict: Post information if successful
+        dict: Error information if failed
+    """
+    try:
+        if not validate_reddit_credentials(client_id, client_secret, username, password):
+            return {"error": "Invalid or missing Reddit credentials"}
+
+        if not title:
+            return {"error": "Post title is required"}
+
+        if not subreddit:
+            return {"error": "Subreddit is required"}
+
+        # Initialize Reddit client
+        reddit = praw.Reddit(
+            client_id=client_id,
+            client_secret=client_secret,
+            username=username,
+            password=password,
+            user_agent=f"python:flowify:v1.0 (by /u/{username})"
+        )
+
+        # Verify credentials
+        try:
+            reddit.user.me()
+        except Exception:
+            return {"error": "Failed to authenticate with Reddit"}
+
+        # Create post
+        try:
+            subreddit_instance = reddit.subreddit(subreddit)
+            post = subreddit_instance.submit(
+                title=title,
+                selftext=body,
+                send_replies=True
+            )
+
+            return {
+                "success": True,
+                "post_id": post.id,
+                "url": f"https://reddit.com{post.permalink}"
+            }
+
+        except praw.exceptions.RedditAPIException as e:
+            error_messages = [f"{error.error_type}: {error.message}" for error in e.items]
+            return {"error": f"Reddit API error: {', '.join(error_messages)}"}
+
+    except praw.exceptions.PRAWException as e:
+        logger.error(f"PRAW error: {str(e)}")
+        return {"error": f"Reddit error: {str(e)}"}
+    except Exception as e:
+        logger.error(f"Unexpected error creating Reddit post: {str(e)}")
+        return {"error": f"Failed to create post: {str(e)}"}

nodes/socialmedia/x.py

@@ -0,0 +1,73 @@
+import logging
+from typing import Union, Dict
+import tweepy
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TwitterError(Exception):
+    """Custom exception for Twitter API errors"""
+    pass
+
+def validate_credentials(login: Dict[str, str]) -> bool:
+    """Validate Twitter API credentials"""
+    required_keys = ['api_key', 'secret_key', 'bearer_key', 'access_token', 'access_token_secret']
+    return all(key in login and login[key] for key in required_keys)
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+    reraise=True
+)
+def create_tweet(text: str, login: Dict[str, str]) -> Union[Dict[str, str], Dict[str, str]]:
+    """
+    Create a tweet with improved error handling and retries
+    
+    Args:
+        text (str): Tweet content
+        login (dict): Twitter API credentials
+        
+    Returns:
+        dict: Tweet information if successful
+        dict: Error information if failed
+    """
+    try:
+        if not text:
+            return {"error": "No tweet content provided"}
+
+        if not validate_credentials(login):
+            return {"error": "Invalid or missing Twitter credentials"}
+
+        if len(text) > 280:
+            return {"error": "Tweet exceeds 280 characters"}
+
+        # Initialize Twitter client
+        client = tweepy.Client(
+            bearer_token=login['bearer_key'],
+            consumer_key=login['api_key'],
+            consumer_secret=login['secret_key'],
+            access_token=login['access_token'],
+            access_token_secret=login['access_token_secret']
+        )
+
+        # Create tweet
+        response = client.create_tweet(text=text)
+
+        if response and response.data:
+            tweet_id = response.data['id']
+            return {
+                "success": True,
+                "tweet_id": tweet_id,
+                "url": f"https://twitter.com/user/status/{tweet_id}"
+            }
+        else:
+            return {"error": "Failed to create tweet: No response data"}
+
+    except tweepy.TweepyException as e:
+        logger.error(f"Twitter API error: {str(e)}")
+        return {"error": f"Twitter API error: {str(e)}"}
+    except Exception as e:
+        logger.error(f"Unexpected error creating tweet: {str(e)}")
+        return {"error": f"Failed to create tweet: {str(e)}"}

requirements.txt

@@ -0,0 +1,10 @@
+beautifulsoup4==4.13.3
+curl_cffi==0.7.4
+fastapi==0.115.12
+instabot==0.117.0
+linkedin_api==2.3.1
+praw==7.8.1
+Pyrebase4==4.8.0
+tenacity==9.0.0
+tweepy==4.14.0
+uvicorn

run.py

@@ -0,0 +1,5 @@
+from app import app
+
+if __name__ == '__main__':
+    app.run(port=5000, debug=True)
+