greeksoft 0.0.1__tar.gz

greeksoft-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Greeksoft Technology Pvt Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

greeksoft-0.0.1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.2
+Name: greeksoft
+Version: 0.0.1
+Summary: GreekSoft Api Client use for trading purpose
+Author: Greek_dev_Team
+Author-email: greeksoftapi@greeksoft.co.in
+License: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websocket>=0.2.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pandas>=1.19.5
+Requires-Dist: websockets>=14.2
+Requires-Dist: websocket-client>=1.8.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# GreekSoft API
+Greeksoft_API is a Python-based project that allows users to subscribe to the Greek token and retrieve the latest tick data. This project helps in authenticating a user, broadcasting tokens, and placing orders in a seamless manner.
+
+# Features Authentication: 
+By passing a username, session password, and user password, the project authenticates the user.
+# Token Retrieval: 
+Retrieves the latest token broadcast.
+# Order Placement: 
+Capable of placing orders once authenticated.
+
+# Technologies Used
+Python built-in Libs & third party libs (Pandas, numpy,requests,etc.)
+```
+pip install greeksoft
+```
+
+Usage
+Once installed, you can use the project by importing the Greek_API from the greek_api_client package. Below is an example of how to use the API:
+
+```
+from greeksoft import Greek_API
+
+username="username" # String Format
+
+session_pwd="session_pwd"  #String Format
+
+user_pwd="user_pwd" #String Format
+
+procli="procli" # for client id procli="2", retail id procli='1'
+
+ac_no='ac_no' # if retail id pass account number in String Format. 
+
+api = Greek_API(username,session_pwd,user_pwd,procli,ac_no) #to authenticate the creadentials passed.
+
+token_no='102000000' # string format
+
+# Authenticate and fetch the latest token
+
+token = api.token_broadcast('token_no','asset_type') # token_no in 'String', asset_type='option' or 'future' or 'equity' in string format.
+
+# token=token['data.token'][0] <-- get token no
+
+# symbol=token['data.symbol'][0] <-- get symbol name of token passed
+
+# time=token['data.ltt'][0] <-- provide the time
+
+# strike=token['data.strikeprice'][0] <-- get Strike 
+
+# option_type=token['data.optiontype'][0] <-- get Option type CE or PE
+
+# instrument=token['data.instrument'][0] <-- get instrument type FUTSTK,OPTSTK...
+
+# bid_price=token[data.bid][0] <-- get bid price of token passed 
+
+# ask_price=token['data.ask'][0] <-- get ask price of token passed
+
+
+# Subscribe with the Greek Token and pass it in list eg:token_list=['','',...] into the declared variable. 
+
+token_list=['102000000','102000000',...] # Only pass Greek Token.
+
+for data in api.get_apollo_resp(token_list): # To get response of tokens passed of list using loop.
+    print(data)
+    
+# Place order passing required paramets, # token_no='102000000', symbol="RELIANCE", qty="minimum_lot" for respective token,
+
+# price= value get from bid/ask price from token broadcast against respective token,
+
+#buysell= if buy then pass 1 and for sell 2 in integer format,
+
+ordtype=1, trigprice=0, strategyname="example" strategy name will be anything as per userinput.
+
+var_response=api.place_order(tokenno,symbol,qty,price,buysell,ordtype,trigprice,strategyname) # pass the required parameters
+ 
+print(var_response) # acknowledge the response get from place order function.
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+
+
+

greeksoft-0.0.1/README.md

@@ -0,0 +1,84 @@
+# GreekSoft API
+Greeksoft_API is a Python-based project that allows users to subscribe to the Greek token and retrieve the latest tick data. This project helps in authenticating a user, broadcasting tokens, and placing orders in a seamless manner.
+
+# Features Authentication: 
+By passing a username, session password, and user password, the project authenticates the user.
+# Token Retrieval: 
+Retrieves the latest token broadcast.
+# Order Placement: 
+Capable of placing orders once authenticated.
+
+# Technologies Used
+Python built-in Libs & third party libs (Pandas, numpy,requests,etc.)
+```
+pip install greeksoft
+```
+
+Usage
+Once installed, you can use the project by importing the Greek_API from the greek_api_client package. Below is an example of how to use the API:
+
+```
+from greeksoft import Greek_API
+
+username="username" # String Format
+
+session_pwd="session_pwd"  #String Format
+
+user_pwd="user_pwd" #String Format
+
+procli="procli" # for client id procli="2", retail id procli='1'
+
+ac_no='ac_no' # if retail id pass account number in String Format. 
+
+api = Greek_API(username,session_pwd,user_pwd,procli,ac_no) #to authenticate the creadentials passed.
+
+token_no='102000000' # string format
+
+# Authenticate and fetch the latest token
+
+token = api.token_broadcast('token_no','asset_type') # token_no in 'String', asset_type='option' or 'future' or 'equity' in string format.
+
+# token=token['data.token'][0] <-- get token no
+
+# symbol=token['data.symbol'][0] <-- get symbol name of token passed
+
+# time=token['data.ltt'][0] <-- provide the time
+
+# strike=token['data.strikeprice'][0] <-- get Strike 
+
+# option_type=token['data.optiontype'][0] <-- get Option type CE or PE
+
+# instrument=token['data.instrument'][0] <-- get instrument type FUTSTK,OPTSTK...
+
+# bid_price=token[data.bid][0] <-- get bid price of token passed 
+
+# ask_price=token['data.ask'][0] <-- get ask price of token passed
+
+
+# Subscribe with the Greek Token and pass it in list eg:token_list=['','',...] into the declared variable. 
+
+token_list=['102000000','102000000',...] # Only pass Greek Token.
+
+for data in api.get_apollo_resp(token_list): # To get response of tokens passed of list using loop.
+    print(data)
+    
+# Place order passing required paramets, # token_no='102000000', symbol="RELIANCE", qty="minimum_lot" for respective token,
+
+# price= value get from bid/ask price from token broadcast against respective token,
+
+#buysell= if buy then pass 1 and for sell 2 in integer format,
+
+ordtype=1, trigprice=0, strategyname="example" strategy name will be anything as per userinput.
+
+var_response=api.place_order(tokenno,symbol,qty,price,buysell,ordtype,trigprice,strategyname) # pass the required parameters
+ 
+print(var_response) # acknowledge the response get from place order function.
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+
+
+

greeksoft-0.0.1/greeksoft/__init__.py

@@ -0,0 +1 @@
+from .greeksoftapi import GreekAPI

greeksoft-0.0.1/greeksoft/greeksoftapi.py

@@ -0,0 +1,369 @@
+import pandas as pd
+import requests as req
+import hashlib
+import base64
+import json
+import time
+import threading as mt
+import websocket as wb
+import ssl
+
+class GreekAPI:
+    def __init__(self, user,s_pwd, pwd,procli,ac_no):
+        self.username = user
+        self.session_pwd = s_pwd
+        self.userpwd = pwd
+        self.gscid = self.username
+        self.session_id = None
+        self.ws_apollo = None
+        self.procli=procli
+        self.url_session_token ='http://greekapi.greeksoft.in:3001'
+        self.is_secure=False
+        self.is_base64 = True
+        self.rest_ip = "dev.greeksoft.in"
+        self.rest_port = "3333"
+        self.session_token = self.get_session_token()
+        self.ac_no=ac_no
+        if self.is_secure :
+            self.ssl_verify = False
+            self.wbhd = "https://"
+            self.wshd = "wss://"
+        else:
+            self.ssl_verify = False
+            self.wbhd = "http://"
+            self.wshd = "ws://"
+        self.gcid=self.getlogininfo()
+    def base64_to_json(self, coded_string):
+        string = base64.b64decode(coded_string).decode('utf-8')
+        return json.loads(string)
+
+    def get_session_token(self):
+        url = f'{self.url_session_token}/auth/greek/sessiontoken'
+        myobj = {
+            "username": str(self.username),
+            "password": str(self.session_pwd),
+            "validFor": str("1d")
+        }
+
+        response = req.post(url, json=myobj)
+        response.raise_for_status()  # Raise an error for bad responses
+
+        # Get the session token from the response
+        session_token = response.json().get('sessionToken')
+
+        return session_token
+
+    def json_to_base64(self, string):
+        string = json.dumps(string)
+        coded_string = base64.b64encode(string.encode('utf-8'))
+        coded_string = repr(coded_string)[2:-1]
+        return coded_string
+
+    def get_url(self,servicename):
+        svcname = servicename
+        url = self.wbhd+self.rest_ip+ ":"+self.rest_port+"/"+svcname
+        return url
+    def token_broadcast(self,tokenno, assettype):
+        gcid=self.getlogininfo()
+        params = {
+            "request": {
+                "data": {
+                    "token": tokenno,
+                    "assetType": assettype,
+                    "gscid": str(self.username),
+                    "gcid": str(gcid),
+                },
+                "svcName": "getQuoteForSingleSymbol_V2",
+                "svcGroup": "Markets"
+            }
+        }
+        params = self.json_to_base64(params)
+        stoken = self.session_token
+        headers = { "Authorization":""+str(stoken) ,"charset": "utf-8", "Content-Type": "application/json" }
+        svcname = "getQuoteForSingleSymbol_V2"
+        url_neworder = self.get_url(svcname)
+        y1 =  req.post(url_neworder,data=params,headers=headers ,verify=self.ssl_verify )
+        y1 = y1.text
+        z1 = self.base64_to_json(y1)
+        df_broadcast_response = pd.json_normalize(z1['response'])
+        return df_broadcast_response
+
+    def getlogininfo(self):
+        svcname = "getLoginInfo"
+        url_getlogininfo = self.get_url(svcname)
+        stoken = self.session_token
+        headers = { "Authorization":""+str(stoken) ,"charset": "utf-8", "Content-Type": "application/json" }
+        svc_req = {
+            "request": {
+                "svcVersion": "1.0.0",
+                "svcGroup": "Login",
+                "svcName": "getlogininfo",
+                "assetType": "",
+                "data": {
+                    "gscid": str(self.username)
+                }
+            }
+        }
+        if self.is_base64 :
+            svc_req = self.json_to_base64(svc_req)
+        svc_res =  req.request("POST",url=url_getlogininfo,data=svc_req,headers=headers,verify=False )
+        if self.is_base64 :
+            svc_res = svc_res.text
+            svc_res = self.base64_to_json(svc_res)
+        # print(svc_res)
+        gcid = svc_res['response']['data']['gcid']
+        return gcid
+
+    def jlogin_new(self):
+        url_jloginnew = f"http://{self.rest_ip}:{self.rest_port}/jloginNew"
+        pwdhash = hashlib.md5(self.userpwd.encode()).hexdigest()
+        svc_req = {
+            "request": {
+                "data": {
+                    "gscid": str(self.username),
+                    "deviceDetails": "",
+                    "deviceType": "0",
+                    "pass": str(pwdhash),
+                    "transPass": "",
+                    "userType": "Customer",
+                    "brokerid": "1",
+                    "passType": "0",
+                    "version_no": "1.0.1.10",
+                    "encryptionType": "1"
+                },
+                "svcName": "jloginNew",
+                "svcGroup": "Login"
+            }
+        }
+
+        if self.is_base64:
+            svc_req = self.json_to_base64(svc_req)
+
+        headers = {"Authorization": self.session_token, "charset": "utf-8", "Content-Type": "application/json"}
+        svc_res = req.post(url_jloginnew, data=svc_req, headers=headers, verify=False)
+        if self.is_base64:
+            svc_res = self.base64_to_json(svc_res.text)
+
+        session_id = svc_res['response']['sessionId']
+        self.session_id=session_id
+        websocket_broadcast_ip = svc_res['response']['data']['Apollo_IP']
+        websocket_broadcast_port = svc_res['response']['data']['Apollo_Port']
+        websocket_order_ip = svc_res['response']['data']['Iris_IP']
+        return session_id, websocket_broadcast_ip, websocket_broadcast_port, websocket_order_ip
+
+    def Net_Position_Details_strategywise(self):
+        svcname = "getStrategyNameWiseNetPositionDetail?"
+        url_neworder = self.get_url(svcname)
+        #ord_status = req.get(f"{url_neworder}/{ord_id}")
+        text = "gscid={}".format(str(self.username))
+
+        # text = text.replace('"', '')
+        # info = json_to_base64(text)
+        coded_string = base64.b64encode(text.encode('utf-8'))
+        coded_string = repr(coded_string)[2:-1]
+        info = url_neworder + coded_string
+
+
+        # params = {
+        #     "request": {
+        #         "FormFactor": "M",
+        #         "data": {
+        #             "gcid": str(gcid),
+        #             "gscid": str(username)
+        #         },
+        #         "svcGroup": "portfolio",
+        #         "svcVersion": "1.0.0",
+        #         "streaming_type": str(svcname),
+        #         "request_type": "subscribe"
+        #     }
+        # }
+        # params = json_to_base64(params)
+        stoken = self.session_token
+        headers = { "Authorization":""+str(stoken) ,"charset": "utf-8", "Content-Type": "application/json" }
+        y1 =  req.request("GET", info, headers=headers ,verify=self.ssl_verify )
+        y1 = y1.text
+        z1 = self.base64_to_json(y1)
+        response = z1
+
+        return response
+
+    def send_apollo_resp(self):
+        jln = self.jlogin_new()
+        session_id = jln[0]
+        # bgcid=self.get_gscid_and_stoken()
+        gcid=self.gcid
+        print(session_id)
+        # session_id = jln['response']['sessionId']
+        ws_apollo = wb.create_connection(f"ws://{self.rest_ip}:3032", sslopt={"cert_reqs": ssl.CERT_NONE})
+        self.ws_apollo=ws_apollo
+        apollo_login_req = {"request": {"data": {"gscid": str(self.username),"gcid": str(gcid),"sessionId": str(session_id),"device_type": "0"},"response_format": "json","request_type": "subscribe","streaming_type": "login"}}
+        apollo_login_req = self.json_to_base64(apollo_login_req)
+        ws_apollo.send( apollo_login_req )
+        apollo_login_res = ws_apollo.recv()
+        apollo_login_res = self.base64_to_json(apollo_login_res)
+        print("Apollo Login Response:", apollo_login_res)
+
+
+        t1 = mt.Thread( target=self.heartbeat_req)
+        t1.start()
+
+
+
+    def heartbeat_req(self):
+        gcid=self.gcid
+        ws_apollo = wb.create_connection(f"ws://{self.rest_ip}:3032", sslopt={"cert_reqs": ssl.CERT_NONE})
+
+        apollo_hb_req = {"request": {"data": {"gcid": str(gcid),"sessionId": str(self.session_id) },"response_format": "json","request_type": "subscribe","streaming_type": "HeartBeat"}}
+        apollo_hb_req = self.json_to_base64(apollo_hb_req)
+        while True:
+            ws_apollo.send( apollo_hb_req )
+            time.sleep(20)
+
+    def thread_function(self,stop_event):
+        while not stop_event.is_set():
+            apollo_res = self.base64_to_json(self.ws_apollo.recv())
+            service_name = apollo_res['response']['svcName']
+            streaming = apollo_res['response']['streaming_type']
+            if service_name == 'Broadcast' and streaming == 'marketPicture':
+                token = apollo_res['response']['data']['symbol']
+                # if s1_nifty["symbol"] == token:
+                # print("HI")
+                # "hi"
+
+    def subscribe_token(self, token):
+        apo_login=self.send_apollo_resp()
+        gcid=self.gcid
+        self.gscid=self.username
+        if self.gscid and self.session_id and len(token)<=50:
+            for tkn in token:
+                s1_nifty = {"symbol": str(tkn)}
+                apollo_subscribe_req_n = {
+                    "request": {
+                        "data": {
+                            "symbols": [s1_nifty]
+                        },
+                        "response_format": "json",
+                        "gscid": str(self.username),
+                        "gcid": gcid,  # Assuming gcid is the same as gscid for this example
+                        "request_type": "subscribe",
+                        "streaming_type": "marketPicture"
+                    }
+                }
+                apollo_subscribe_req_n = self.json_to_base64(apollo_subscribe_req_n)
+                self.ws_apollo.send(apollo_subscribe_req_n)
+                print(f"Subscribed to token: {tkn}")
+        else:
+            print("Cannot subscribe. Session ID or GCID is not set.")
+
+    def unsubscribe_token(self,token):
+        gcid=self.gcid
+        username=self.username
+        if gcid and username:
+            s1_nifty = {"symbol": str(token)}
+            apollo_unsubscribe_req_n={
+                "request": {
+                    "data": {
+                        "symbols": [
+                            {
+                                "symbol": [s1_nifty]
+                            }
+                        ]
+                    },
+                    "response_format": "json",
+                    "gscid": str(self.username),
+                    "gcid": gcid,
+                    "request_type": "unsubscribe",
+                    "streaming_type": "marketPicture"
+                }
+            }
+            apollo_unsubscribe_req_n = self.json_to_base64(apollo_unsubscribe_req_n)
+            self.ws_apollo.send(apollo_unsubscribe_req_n)
+            return f"UnSubscribed to token: {token}"
+
+
+    def get_apollo_resp(self,token,req_data):
+        subs=self.subscribe_token(token)
+        while True:
+            apollo_res = self.ws_apollo.recv()
+            apollo_res = self.base64_to_json(apollo_res)
+            service_name = apollo_res['response']['svcName']
+            streaming = apollo_res['response']['streaming_type']
+            if service_name == 'Broadcast' and streaming == 'marketPicture':
+                # print("Market Picture Data:", apollo_res['response']['data'])
+                tkn=apollo_res['response']['data']['symbol']
+                sym=apollo_res['response']['data']['name']
+                ltp=apollo_res['response']['data']['ltp']
+                ltt=apollo_res['response']['data']['ltt']
+                bid=apollo_res['response']['data']['bid']
+                ask=apollo_res['response']['data']['ask']
+                depth=apollo_res['response']['data']['level2']
+                app_res=apollo_res['response']['data']
+                if req_data =='depth':
+                    yield tkn,sym,depth,ltt
+                elif req_data =='ask/bid':
+                    yield tkn,sym,bid,ask,ltt
+                elif req_data=='allresp':
+                    yield app_res
+                else:
+                    yield tkn,sym,ltp,ltt
+                # time.sleep(0.5)
+
+
+    def place_order(self,tokenno,symbol,lot,qty,price,buysell,ordtype,trigprice,strategyname):
+        gcid=self.gcid
+        params = {
+            "request": {
+                "data": {
+                    "trigger_price": str(trigprice),
+                    "gtoken": str(tokenno),
+                    "side": str(buysell),
+                    "gcid": str(gcid),
+                    "validity": "0",
+                    "price": str(price),
+                    "exchange": "NSE",
+                    "disclosed_qty": "0",
+                    "tradeSymbol": str(symbol),
+                    "lot": str(lot),
+                    "iprocli":str(self.procli),
+                    "order_type": str(ordtype),
+                    "product": "0",
+                    "qty": str(qty),
+                    "corderid": "3",
+                    "amo": "0",
+                    "AccountNumber":str(self.ac_no),
+                    "is_restapi":"1",
+                    "gtdExpiry": 0,
+                    "is_post_closed": "0",
+                    "is_preopen_order": "0",
+                    "isSqOffOrder": "false",
+                    "offline": "0",
+                    "strategyName":str(strategyname),
+                    "strategyNo":"124"
+                },
+                "response_format": "json",
+                "request_type": "subscribe",
+                "streaming_type": "NewOrderRequest"
+            }
+        }
+
+        if self.procli != "1":
+            # Remove 'AccountNumber' and 'is_restapi' from the data dictionary if procli is not "1"
+            del params["request"]["data"]["AccountNumber"]
+            del params["request"]["data"]["is_restapi"]
+
+        params = self.json_to_base64(params)
+        stoken = self.get_session_token()
+        headers = { "Authorization":""+str(stoken) ,"charset": "utf-8", "Content-Type": "application/json" }
+        svcname = "NewOrderRequest"
+        url_neworder = self.get_url(svcname)
+        y1 =  req.post(url_neworder,data=params,headers=headers ,verify=self.ssl_verify )
+        y1 = y1.text
+        z1 = self.base64_to_json(y1)
+        df_order_response = pd.json_normalize(z1['response'])
+        return df_order_response
+
+
+    def close_connection(self):
+        if self.ws_apollo:
+            self.ws_apollo.close()
+            print("WebSocket connection closed.")

greeksoft-0.0.1/greeksoft.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.2
+Name: greeksoft
+Version: 0.0.1
+Summary: GreekSoft Api Client use for trading purpose
+Author: Greek_dev_Team
+Author-email: greeksoftapi@greeksoft.co.in
+License: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websocket>=0.2.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pandas>=1.19.5
+Requires-Dist: websockets>=14.2
+Requires-Dist: websocket-client>=1.8.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# GreekSoft API
+Greeksoft_API is a Python-based project that allows users to subscribe to the Greek token and retrieve the latest tick data. This project helps in authenticating a user, broadcasting tokens, and placing orders in a seamless manner.
+
+# Features Authentication: 
+By passing a username, session password, and user password, the project authenticates the user.
+# Token Retrieval: 
+Retrieves the latest token broadcast.
+# Order Placement: 
+Capable of placing orders once authenticated.
+
+# Technologies Used
+Python built-in Libs & third party libs (Pandas, numpy,requests,etc.)
+```
+pip install greeksoft
+```
+
+Usage
+Once installed, you can use the project by importing the Greek_API from the greek_api_client package. Below is an example of how to use the API:
+
+```
+from greeksoft import Greek_API
+
+username="username" # String Format
+
+session_pwd="session_pwd"  #String Format
+
+user_pwd="user_pwd" #String Format
+
+procli="procli" # for client id procli="2", retail id procli='1'
+
+ac_no='ac_no' # if retail id pass account number in String Format. 
+
+api = Greek_API(username,session_pwd,user_pwd,procli,ac_no) #to authenticate the creadentials passed.
+
+token_no='102000000' # string format
+
+# Authenticate and fetch the latest token
+
+token = api.token_broadcast('token_no','asset_type') # token_no in 'String', asset_type='option' or 'future' or 'equity' in string format.
+
+# token=token['data.token'][0] <-- get token no
+
+# symbol=token['data.symbol'][0] <-- get symbol name of token passed
+
+# time=token['data.ltt'][0] <-- provide the time
+
+# strike=token['data.strikeprice'][0] <-- get Strike 
+
+# option_type=token['data.optiontype'][0] <-- get Option type CE or PE
+
+# instrument=token['data.instrument'][0] <-- get instrument type FUTSTK,OPTSTK...
+
+# bid_price=token[data.bid][0] <-- get bid price of token passed 
+
+# ask_price=token['data.ask'][0] <-- get ask price of token passed
+
+
+# Subscribe with the Greek Token and pass it in list eg:token_list=['','',...] into the declared variable. 
+
+token_list=['102000000','102000000',...] # Only pass Greek Token.
+
+for data in api.get_apollo_resp(token_list): # To get response of tokens passed of list using loop.
+    print(data)
+    
+# Place order passing required paramets, # token_no='102000000', symbol="RELIANCE", qty="minimum_lot" for respective token,
+
+# price= value get from bid/ask price from token broadcast against respective token,
+
+#buysell= if buy then pass 1 and for sell 2 in integer format,
+
+ordtype=1, trigprice=0, strategyname="example" strategy name will be anything as per userinput.
+
+var_response=api.place_order(tokenno,symbol,qty,price,buysell,ordtype,trigprice,strategyname) # pass the required parameters
+ 
+print(var_response) # acknowledge the response get from place order function.
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+
+
+

greeksoft-0.0.1/greeksoft.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+setup.py
+greeksoft/__init__.py
+greeksoft/greeksoftapi.py
+greeksoft.egg-info/PKG-INFO
+greeksoft.egg-info/SOURCES.txt
+greeksoft.egg-info/dependency_links.txt
+greeksoft.egg-info/requires.txt
+greeksoft.egg-info/top_level.txt

greeksoft-0.0.1/greeksoft.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

greeksoft-0.0.1/greeksoft.egg-info/requires.txt

@@ -0,0 +1,5 @@
+websocket>=0.2.1
+requests>=2.32.3
+pandas>=1.19.5
+websockets>=14.2
+websocket-client>=1.8.0

greeksoft-0.0.1/greeksoft.egg-info/top_level.txt

@@ -0,0 +1 @@
+greeksoft

greeksoft-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

greeksoft-0.0.1/setup.py

@@ -0,0 +1,25 @@
+import pathlib
+from platform import python_version
+
+from setuptools import setup,find_packages
+
+setup(name="greeksoft",
+      version='0.0.1',
+      description="GreekSoft Api Client use for trading purpose",
+      long_description=pathlib.Path("README.md").read_text(),
+      long_description_content_type='text/markdown',
+      author="Greek_dev_Team",
+      author_email='greeksoftapi@greeksoft.co.in',
+      license="MIT License",
+      packages=find_packages(),
+      install_requires=[
+            'websocket>=0.2.1',
+            'requests>=2.32.3',
+            'pandas>=1.19.5',
+            'websockets>=14.2',
+            'websocket-client>=1.8.0'
+      ],
+      python_version="=>3.10",
+      include_package_data=True,
+
+      )