MindsDB 1.3.1__py3-none-any.whl → 25.1.2.0__py3-none-any.whl

mindsdb/integrations/handlers/frappe_handler/frappe_client.py

@@ -0,0 +1,111 @@
+import json
+import requests
+from typing import Dict, List
+
+
+class FrappeClient(object):
+    """Client to interact with the Frappe API.
+    
+    Attributes:
+        domain (str): Path to Frappe domain to use (e.g. https://mindsdbfrappe.com).
+        access_token (str): Frappe authorization token to use for all API requests.
+    """
+
+    def __init__(
+            self,
+            domain: str,
+            access_token: str):
+        self.domain = domain
+        self.base_url = f'{self.domain}/api'
+        self.access_token = access_token
+
+        self.headers = {
+            'Authorization': f'token {self.access_token}',
+        }
+
+    def get_document(self, doctype: str, name: str) -> Dict:
+        """Gets a document matching the given doctype from Frappe.
+        
+        See https://frappeframework.com/docs/v14/user/en/api/rest#listing-documents
+        Args:
+            doctype (str): The document type to retrieve.
+            name (str): Name of the document.
+        """
+        document_response = requests.get(
+            f'{self.base_url}/resource/{doctype}/{name}',
+            headers=self.headers)
+        if not document_response.ok:
+            document_response.raise_for_status()
+        return document_response.json()['data']
+
+    def get_documents(self, doctype: str, limit: int = None, fields: List[str] = None, filters: List[List] = None) -> List[Dict]:
+        """Gets all documents matching the given doctype from Frappe.
+        
+        See https://frappeframework.com/docs/v14/user/en/api/rest#listing-documents
+        Args:
+            doctype (str): The document type to retrieve.
+            limit (int): At most, how many messages to return.
+            filters (List[List]): List of filters in the form [field, operator, value] e.g. ["amount", ">", 50]
+        """
+        params = {
+            'fields': json.dumps(["*"])
+        }
+        if limit is not None:
+            params['limit_page_length'] = limit
+        if filters is not None:
+            params['filters'] = json.dumps(filters)
+        if fields is not None:
+            params['fields'] = json.dumps(fields)
+        documents_response = requests.get(
+            f'{self.base_url}/resource/{doctype}/',
+            params=params,
+            headers=self.headers,
+            allow_redirects=False)
+        if documents_response.is_redirect:
+            # We have to manually redirect to preserve the 'Authorization' header.
+            # See https://github.com/request/request/pull/1184/commits/210b326fd8625f358e06c59dc11e74468b1de515.
+            redirect_url = documents_response.headers.get('location', None)
+            if redirect_url is None:
+                raise requests.HTTPError('Could not find redirect URL')
+            documents_response = requests.get(
+                redirect_url,
+                params=params,
+                headers=self.headers,
+                allow_redirects=False)
+
+        if not documents_response.ok:
+            documents_response.raise_for_status()
+        return documents_response.json()['data']
+
+    def post_document(
+            self,
+            doctype: str,
+            data: Dict):
+        """Creates a new document of the given doctype.
+        See https://frappeframework.com/docs/v14/user/en/api/rest#listing-documents
+        
+        Args:
+            doctype (str): Type of the document to create.
+            data (Dict): Document object.
+        """
+        post_response = requests.post(
+            f'{self.base_url}/resource/{doctype}',
+            json=data,
+            headers=self.headers)
+        if not post_response.ok:
+            if 400 <= post_response.status_code < 600:
+                raise requests.HTTPError(f'{post_response.reason}: {post_response.text}', response=post_response)
+        return post_response.json()['data']
+
+    def ping(self) -> bool:
+        """Sends a basic request to the Frappe API to see if it succeeds.
+        
+        Returns whether or not the connection to the Frappe API is valid.
+        See https://frappeframework.com/docs/v14/user/en/api/rest#1-token-based-authentication
+        """
+
+        # No ping or similar endpoint exists, so we'll try getting the logged in user.
+        user_response = requests.get(
+            f'{self.base_url}/method/frappe.auth.get_logged_user',
+            headers=self.headers)
+        return user_response.ok

mindsdb/integrations/handlers/frappe_handler/frappe_handler.py

@@ -0,0 +1,209 @@
+import json
+import pandas as pd
+import datetime as dt
+from typing import Dict
+
+from mindsdb.integrations.handlers.frappe_handler.frappe_tables import FrappeDocumentsTable
+from mindsdb.integrations.handlers.frappe_handler.frappe_client import FrappeClient
+from mindsdb.integrations.libs.api_handler import APIHandler
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+)
+from mindsdb.utilities import log
+from mindsdb_sql_parser import parse_sql
+
+logger = log.getLogger(__name__)
+
+class FrappeHandler(APIHandler):
+    """A class for handling connections and interactions with the Frappe API.
+
+    Attributes:
+        client (FrappeClient): The `FrappeClient` object for interacting with the Frappe API.
+        is_connected (bool): Whether or not the API client is connected to Frappe.
+        domain (str): Frappe domain to send API requests to.
+        access_token (str): OAuth token to use for authentication.
+    """
+
+    def __init__(self, name: str = None, **kwargs):
+        """Registers all API tables and prepares the handler for an API connection.
+
+        Args:
+            name: (str): The handler name to use
+        """
+        super().__init__(name)
+        self.client = None
+        self.is_connected = False
+
+        args = kwargs.get('connection_data', {})
+        if not 'access_token' in args:
+            raise ValueError('"access_token" parameter required for authentication')
+        if not 'domain' in args:
+            raise ValueError('"domain" parameter required to connect to your Frappe instance')
+        self.access_token = args['access_token']
+        self.domain = args['domain']
+
+        document_data = FrappeDocumentsTable(self)
+        self._register_table('documents', document_data)
+        self.connection_data = args
+
+    def back_office_config(self):
+        tools = {
+            'register_sales_invoice': 'have to be used by assistant to register a sales invoice. Input is JSON object serialized as a string. Due date have to be passed in format: "yyyy-mm-dd".',
+            'check_company_exists': 'useful to check the company is exist. Input is company',
+            'check_expense_type': 'useful to check the expense_type is exist. Input is expense_type',
+            'check_customer':  'useful to check the customer is exist. Input is customer',
+            'check_item_code':  'have to be used to check the item code. Input is item_code',
+        }
+        return {
+            'tools': tools,
+        }
+
+    def register_sales_invoice(self, data):
+        """
+          input is:
+            {
+              "due_date": "2023-05-31",
+              "customer": "ksim",
+              "items": [
+                {
+                  "name": "T-shirt--",
+                  "description": "T-shirt",
+                  "quantity": 1
+                }
+              ]
+            }
+        """
+        invoice = json.loads(data)
+        date = dt.datetime.strptime(invoice['due_date'], '%Y-%m-%d')
+        if date <= dt.datetime.today():
+            return 'Error: due_date have to be in the future'
+
+        for item in invoice['items']:
+            # rename column
+            item['qty'] = item['quantity']
+            del item['quantity']
+
+            # add required fields
+            item['uom'] = "Nos"
+            item['conversion_factor'] = 1
+
+            income_account = self.connection_data.get('income_account', "Sales Income - C8")
+            item['income_account'] = income_account
+
+        try:
+            self.connect()
+            self.client.post_document('Sales Invoice', invoice)
+        except Exception as e:
+            return f"Error: {e}"
+        return f"Success"
+
+    def check_item_code(self, item_code):
+        self.connect()
+        result = self.client.get_documents('Item', filters=[['item_code', '=', item_code]])
+        if len(result) == 1:
+            return True
+        return "Item doesn't exist: please use different name"
+
+    def check_company_exists(self, name):
+        self.connect()
+        result = self.client.get_documents('Company', filters=[['name', '=', name]])
+        if len(result) == 1:
+            return True
+        return "Company doesn't exist: please use different name"
+
+    def check_expense_type(self, name):
+        self.connect()
+        result = self.client.get_documents('Expense Claim Type', filters=[['name', '=', name]])
+        if len(result) == 1:
+            return True
+        return "Expense Claim Type doesn't exist: please use different name"
+
+    def check_customer(self, name):
+        self.connect()
+        result = self.client.get_documents('Customer', filters=[['name', '=', name]])
+        if len(result) == 1:
+            return True
+        return "Customer doesn't exist"
+
+    def connect(self) -> FrappeClient:
+        """Creates a new  API client if needed and sets it as the client to use for requests.
+
+        Returns newly created Frappe API client, or current client if already set.
+        """
+        if self.is_connected is True and self.client:
+            return self.client
+
+        if self.domain and self.access_token:
+            self.client = FrappeClient(self.domain, self.access_token)
+
+        self.is_connected = True
+        return self.client
+
+    def check_connection(self) -> StatusResponse:
+        """Checks connection to Frappe API by sending a ping request.
+
+        Returns StatusResponse indicating whether or not the handler is connected.
+        """
+
+        response = StatusResponse(False)
+
+        try:
+            client = self.connect()
+            client.ping()
+            response.success = True
+
+        except Exception as e:
+            logger.error(f'Error connecting to Frappe API: {e}!')
+            response.error_message = e
+
+        self.is_connected = response.success
+        return response
+
+    def native_query(self, query: str = None) -> Response:
+        ast = parse_sql(query)
+        return self.query(ast)
+
+    def _document_to_dataframe_row(self, doctype, document: Dict) -> Dict:
+        return {
+            'doctype': doctype,
+            'data': json.dumps(document)
+        }
+
+    def _get_document(self, params: Dict = None) -> pd.DataFrame:
+        client = self.connect()
+        doctype = params['doctype']
+        document = client.get_document(doctype, params['name'])
+        return pd.DataFrame.from_records([self._document_to_dataframe_row(doctype, document)])
+
+    def _get_documents(self, params: Dict = None) -> pd.DataFrame:
+        client = self.connect()
+        doctype = params['doctype']
+        limit = params.get('limit', None)
+        filters = params.get('filters', None)
+        fields = params.get('fields', None)
+        documents = client.get_documents(doctype, limit=limit, fields=fields, filters=filters)
+        return pd.DataFrame.from_records([self._document_to_dataframe_row(doctype, d) for d in documents])
+
+    def _create_document(self, params: Dict = None) -> pd.DataFrame:
+        client = self.connect()
+        doctype = params['doctype']
+        new_document = client.post_document(doctype, json.loads(params['data']))
+        return pd.DataFrame.from_records([self._document_to_dataframe_row(doctype, new_document)])
+
+    def call_frappe_api(self, method_name: str = None, params: Dict = None) -> pd.DataFrame:
+        """Calls the Frappe API method with the given params.
+
+        Returns results as a pandas DataFrame.
+
+        Args:
+            method_name (str): Method name to call (e.g. get_document)
+            params (Dict): Params to pass to the API call
+        """
+        if method_name == 'get_documents':
+            return self._get_documents(params)
+        if method_name == 'get_document':
+            return self._get_document(params)
+        if method_name == 'create_document':
+            return self._create_document(params)
+        raise NotImplementedError('Method name {} not supported by Frappe API Handler'.format(method_name))

mindsdb/integrations/handlers/frappe_handler/frappe_tables.py

@@ -0,0 +1,82 @@
+import pandas as pd
+from typing import List
+
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb_sql_parser import ast
+
+
+class FrappeDocumentsTable(APITable):
+
+    def select(self, query: ast.Select) -> pd.DataFrame:
+        """Selects data from the Frappe API and returns it as a pandas DataFrame.
+        
+        Returns dataframe representing the Frappe API results.
+
+        Args:
+            query (ast.Select): Given SQL SELECT query
+        """
+        conditions = extract_comparison_conditions(query.where)
+
+        params = {}
+        filters = []
+        for op, arg1, arg2 in conditions:
+            if arg1 == 'doctype':
+                if op != '=':
+                    raise NotImplementedError
+                params['doctype'] = arg2
+            elif arg1 == 'name':
+                params['name'] = arg2
+            else:
+                filters.append([arg1, op, arg2])
+
+        if not 'doctype' in params:
+            raise ValueError('"doctype" parameter required')
+
+        if query.limit:
+            params['limit'] = query.limit.value
+        if filters:
+            params['filters'] = filters
+
+        if 'name' in params:
+            document_data = self.handler.call_frappe_api(
+                method_name='get_document',
+                params=params
+            )
+        else:
+            document_data = self.handler.call_frappe_api(
+                method_name='get_documents',
+                params=params
+            )
+
+        # Only return the columns we need to.
+        columns = []
+        for target in query.targets:
+            if isinstance(target, ast.Star):
+                columns = document_data.columns
+                break
+            elif isinstance(target, ast.Identifier):
+                columns.append(target.parts[-1])
+            else:
+                raise NotImplementedError
+
+        if len(document_data) == 0:
+            return pd.DataFrame([], columns=columns)
+
+        # Remove columns not part of select.
+        for col in set(document_data.columns).difference(set(columns)):
+            document_data = document_data.drop(col, axis=1)
+
+        return document_data
+
+    def insert(self, query: ast.Insert) -> pd.DataFrame:
+        columns = [col.name for col in query.columns]
+
+        for row in query.values:
+            params = dict(zip(columns, row))
+
+            self.handler.call_frappe_api('create_document', params)
+
+    def get_columns(self) -> List:
+        """Gets all columns to be returned in pandas DataFrame responses"""
+        return ['doctype', 'data']

mindsdb/integrations/handlers/frappe_handler/icon.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <g clip-path="url(#clip0_146_330)">
+    <path d="M40 35C40 37.75 37.75 40 35 40H5C2.25 40 0 37.75 0 35V5C0 2.25 2.25 0 5 0H35C37.75 0 40 2.25 40 5V35Z" fill="#7574FF"/>
+    <path d="M11.7565 29.0378V11.0274C11.7565 9.84244 12.5013 9.06384 13.6184 9.06384H26.3138C27.397 9.06384 27.9387 9.60548 27.9387 10.5195V10.7227C27.9387 11.6706 27.397 12.1784 26.3138 12.1784H15.2434V18.306H23.8086C24.9258 18.306 25.4336 18.7799 25.4336 19.6941V19.7956C25.4336 20.7435 24.8919 21.2513 23.8086 21.2513H15.2435V27.8868H26.517C27.6003 27.8868 28.1081 28.3607 28.1081 29.2749V29.4442C28.1081 30.4259 27.6003 30.9676 26.517 30.9676H13.6185C12.5013 30.9675 11.7565 30.2227 11.7565 29.0378Z" fill="white"/>
+  </g>
+  <defs>
+    <clipPath id="clip0_146_330">
+      <rect width="40" height="40" fill="white"/>
+    </clipPath>
+  </defs>
+</svg>

mindsdb/integrations/handlers/gcs_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB GCS handler'
+__package_name__ = 'mindsdb_gcs_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for Google Cloud Storage"
+__author__ = 'Abhilash K R'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/gcs_handler/__init__.py

@@ -0,0 +1,20 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+try:
+    from .gcs_handler import GcsHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Google Cloud Storage'
+name = 'gcs'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description',
+    'connection_args', 'connection_args_example', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/gcs_handler/connection_args.py

@@ -0,0 +1,29 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+connection_args = OrderedDict(
+    bucket={
+        'type': ARG_TYPE.STR,
+        'description': 'The name of the GCS bucket.',
+        'label': 'GCS Bucket'
+    },
+    service_account_keys={
+        'type': ARG_TYPE.PATH,
+        'description': 'Path to the service account JSON file',
+        'label': 'Path to the service account JSON file',
+        'secret': True
+    },
+    service_account_json={
+        'type': ARG_TYPE.DICT,
+        'description': 'Content of service account JSON file',
+        'label': 'Content of service account JSON file',
+        'secret': True
+    }
+)
+
+
+connection_args_example = OrderedDict(
+    bucket='my-bucket',
+    service_account_keys='/Users/sam/Downloads/svc.json'
+)