Metadata-Version: 2.1
Name: smartapi-python
Version: 1.4.1
Summary: Angel Broking openApi integration
Home-page: https://github.com/angelbroking-github/smartapi-python
Author: ab-smartapi
Author-email: smartapi.sdk@gmail.com
License: UNKNOWN
Description: # SMARTAPI-PYTHON
        
        SMARTAPI-PYTHON is a Python library for interacting with Angel's Trading platform  ,that is a set of REST-like HTTP APIs that expose many capabilities required to build stock market investment and trading platforms. It lets you execute orders in real time..
        
        
        ## Installation
        
        Use the package manager [pip](https://pip.pypa.io/en/stable/) to install smartapi-python.
        
        ```bash
        pip install -r requirements_dev.txt       # for downloading the other required packages
        ```
        
        ## Usage
        
        ```python
        # package import statement
        from SmartApi import SmartConnect #or from SmartApi.smartConnect import SmartConnect
        import pyotp
        from logzero import logger
        
        api_key = 'Your Api Key'
        username = 'Your client code'
        pwd = 'Your pin'
        smartApi = SmartConnect(api_key)
        try:
            token = "Your QR value"
            totp = pyotp.TOTP(token).now()
        except Exception as e:
            logger.error("Invalid Token: The provided token is not valid.")
            raise e
        
        correlation_id = "abcde"
        data = smartApi.generateSession(username, pwd, totp)
        
        if data['status'] == False:
            logger.error(data)
            
        else:
            # login api call
            # logger.info(f"You Credentials: {data}")
            authToken = data['data']['jwtToken']
            refreshToken = data['data']['refreshToken']
            # fetch the feedtoken
            feedToken = smartApi.getfeedToken()
            # fetch User Profile
            res = smartApi.getProfile(refreshToken)
            smartApi.generateToken(refreshToken)
            res=res['data']['exchanges']
        
            #place order
            try:
                orderparams = {
                    "variety": "NORMAL",
                    "tradingsymbol": "SBIN-EQ",
                    "symboltoken": "3045",
                    "transactiontype": "BUY",
                    "exchange": "NSE",
                    "ordertype": "LIMIT",
                    "producttype": "INTRADAY",
                    "duration": "DAY",
                    "price": "19500",
                    "squareoff": "0",
                    "stoploss": "0",
                    "quantity": "1"
                    }
                # Method 1: Place an order and return the order ID
                orderid = smartApi.placeOrder(orderparams)
                logger.info(f"PlaceOrder : {orderid}")
                # Method 2: Place an order and return the full response
                response = smartApi.placeOrderFullResponse(orderparams)
                logger.info(f"PlaceOrder : {response}")
            except Exception as e:
                logger.exception(f"Order placement failed: {e}")
        
            #gtt rule creation
            try:
                gttCreateParams={
                        "tradingsymbol" : "SBIN-EQ",
                        "symboltoken" : "3045",
                        "exchange" : "NSE", 
                        "producttype" : "MARGIN",
                        "transactiontype" : "BUY",
                        "price" : 100000,
                        "qty" : 10,
                        "disclosedqty": 10,
                        "triggerprice" : 200000,
                        "timeperiod" : 365
                    }
                rule_id=smartApi.gttCreateRule(gttCreateParams)
                logger.info(f"The GTT rule id is: {rule_id}")
            except Exception as e:
                logger.exception(f"GTT Rule creation failed: {e}")
                
            #gtt rule list
            try:
                status=["FORALL"] #should be a list
                page=1
                count=10
                lists=smartApi.gttLists(status,page,count)
            except Exception as e:
                logger.exception(f"GTT Rule List failed: {e}")
        
            #Historic api
            try:
                historicParam={
                "exchange": "NSE",
                "symboltoken": "3045",
                "interval": "ONE_MINUTE",
                "fromdate": "2021-02-08 09:00", 
                "todate": "2021-02-08 09:16"
                }
                smartApi.getCandleData(historicParam)
            except Exception as e:
                logger.exception(f"Historic Api failed: {e}")
            #logout
            try:
                logout=smartApi.terminateSession('Your Client Id')
                logger.info("Logout Successfull")
            except Exception as e:
                logger.exception(f"Logout failed: {e}")
        
            ```
        
            ## Getting started with SmartAPI Websocket's
        
            ```python
            ####### Websocket V2 sample code #######
        
            from SmartApi.smartWebSocketV2 import SmartWebSocketV2
            from logzero import logger
        
            AUTH_TOKEN = "Your Auth_Token"
            API_KEY = "Your Api_Key"
            CLIENT_CODE = "Your Client Code"
            FEED_TOKEN = "Your Feed_Token"
            correlation_id = "abc123"
            action = 1
            mode = 1
            token_list = [
                {
                    "exchangeType": 1,
                    "tokens": ["26009"]
                }
            ]
            #retry_strategy=0 for simple retry mechanism
            sws = SmartWebSocketV2(AUTH_TOKEN, API_KEY, CLIENT_CODE, FEED_TOKEN,max_retry_attempt=2, retry_strategy=0, retry_delay=10, retry_duration=30)
        
            #retry_strategy=1 for exponential retry mechanism
            # sws = SmartWebSocketV2(AUTH_TOKEN, API_KEY, CLIENT_CODE, FEED_TOKEN,max_retry_attempt=3, retry_strategy=1, retry_delay=10,retry_multiplier=2, retry_duration=30)
        
            def on_data(wsapp, message):
                logger.info("Ticks: {}".format(message))
                # close_connection()
        
            def on_control_message(wsapp, message):
                logger.info(f"Control Message: {message}")
        
            def on_open(wsapp):
                logger.info("on open")
                some_error_condition = False
                if some_error_condition:
                    error_message = "Simulated error"
                    if hasattr(wsapp, 'on_error'):
                        wsapp.on_error("Custom Error Type", error_message)
                else:
                    sws.subscribe(correlation_id, mode, token_list)
                    # sws.unsubscribe(correlation_id, mode, token_list1)
        
            def on_error(wsapp, error):
                logger.error(error)
        
            def on_close(wsapp):
                logger.info("Close")
        
            def close_connection():
                sws.close_connection()
        
        
            # Assign the callbacks.
            sws.on_open = on_open
            sws.on_data = on_data
            sws.on_error = on_error
            sws.on_close = on_close
            sws.on_control_message = on_control_message
        
            sws.connect()
            ####### Websocket V2 sample code ENDS Here #######
        
            ########################### SmartWebSocket OrderUpdate Sample Code Start Here ###########################
            from SmartApi.smartWebSocketOrderUpdate import SmartWebSocketOrderUpdate
            client = SmartWebSocketOrderUpdate(AUTH_TOKEN, API_KEY, CLIENT_CODE, FEED_TOKEN)
            client.connect()
            ########################### SmartWebSocket OrderUpdate Sample Code End Here ###########################
        ```
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Financial and Insurance Industry
Classifier: Programming Language :: Python
Classifier: Natural Language :: English
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Office/Business :: Financial :: Investment
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Software Development :: Libraries
Description-Content-Type: text/markdown
