fork download 
  1. # ------------------ mypass.json
  2. {
  3.   "info":{
  4.       "password": "zxc"
  5.     }
  6. }
  7.  
  8. # ------------------ k.py
  9.  
  10.  
  11. import os,io,string
  12. import hashlib
  13. from hashlib import sha256
  14. from typing import Dict, List
  15. from urllib import parse
  16. import timeit
  17.  
  18. import configparser
  19. import json
  20. import logging
  21. import time
  22. from datetime import datetime
  23. import requests
  24. from requests import Session
  25.  
  26. from rich.live import Live
  27. from rich.table import Table
  28. from rich.panel import Panel
  29. from rich.layout import Layout
  30. from rich import box
  31.  
  32. # https://i...content-available-to-author-only...e.com/KsRWCW
  33.  
  34. def file_load(filename,encoding='utf8'):
  35.     with io.open(filename,encoding=encoding) as f_in:
  36.         # js=json.load(f_in)
  37.         data=f_in.read()
  38.         f_in.close()
  39.     return data
  40.  
  41. class HiTimer():
  42.     def __init__(self):
  43.         self.startInterval = timeit.default_timer()
  44.         self.endInterval = timeit.default_timer()
  45.     def start(self):
  46.         self.startInterval = timeit.default_timer()
  47.     def elapsedsec(self):
  48.         self.endInterval = timeit.default_timer()
  49.         timeSt=self.endInterval- self.startInterval
  50.         return timeSt
  51.     def elapsedms(self):
  52.         self.endInterval = timeit.default_timer()
  53.         timeSt=(self.endInterval- self.startInterval)*1000.0
  54.         return timeSt
  55.  
  56.  
  57. class KeeneticClient:
  58.  
  59.     def __init__(self, admin_endpoint: str, skip_auth: bool, login: str, password: str):
  60.         self._admin_endpoint = admin_endpoint
  61.         self._skip_auth = skip_auth
  62.         self._login = login
  63.         self._password = password
  64.  
  65.     def __enter__(self):
  66.         self._session = Session()
  67.         return self
  68.  
  69.     def __exit__(self, exc_type, exc_val, exc_tb):
  70.         if self._session:
  71.             self._session.close()
  72.  
  73.     def _auth(self) -> bool:
  74.         if self._skip_auth:
  75.             return True
  76.         auth_endpoint = f"{self._admin_endpoint}/auth"
  77.         check_auth_response = self._session.get(auth_endpoint,timeout=2)
  78.         if check_auth_response.status_code == 401:
  79.             ndm_challenge = check_auth_response.headers.get('X-NDM-Challenge')
  80.             ndm_realm = check_auth_response.headers.get('X-NDM-Realm')
  81.             md5 = hashlib.md5((self._login + ':' + ndm_realm + ':' + self._password).encode('utf-8')).hexdigest()
  82.             sha = sha256((ndm_challenge + md5).encode('utf-8')).hexdigest()
  83.             auth_response = self._session.post(auth_endpoint,timeout=2, json={'login': self._login, 'password': sha})
  84.             if auth_response.status_code == 200:
  85.                 return True
  86.             raise ConnectionError(f"Keenetic authorisation failed. Status {auth_response.status_code}")
  87.         elif check_auth_response.status_code == 200:
  88.             return True
  89.         raise ConnectionError(f"Failed to check authorisation, status unknown ({check_auth_response.status_code})")
  90.  
  91.     def connect(self) -> bool:
  92.         if not self._auth():
  93.             raise ConnectionError(f"No keenetic connection.")
  94.         return True
  95.  
  96.     def do_post(self, command: str, params: Dict) -> Dict:
  97.         if not self._auth():
  98.             raise ConnectionError(f"No keenetic connection.")
  99.  
  100.         url = f"{self._admin_endpoint}{command.replace(' ', '/')}" 
  101.         # prms=parse.urlencode(params)
  102.         post_resp = self._session.post( url  = url, json=params,timeout=2)
  103.         if post_resp.status_code != 200:
  104.             raise KeeneticApiException(post_resp.status_code, post_resp.text)
  105.         return post_resp.json()
  106.  
  107.         # raise ConnectionError(f"Keenetic post failed. Status {post_resp.status_code}")
  108.         #  json = [
  109.         #         {"interface" : {"Dsl0": {"up": {"no": True}}}},
  110.         #         {"system"    : {"configuration": {"save": True}}}
  111.         # ]
  112.  
  113.     def do_get(self, command: str, params: Dict) -> Dict:
  114.         if not self._auth():
  115.             raise ConnectionError(f"No keenetic connection.")
  116.  
  117.         url = f"{self._admin_endpoint}{command.replace(' ', '/')}" + "?" + parse.urlencode(params)
  118.         r = self._session.get(url,timeout=2)
  119.         if r.status_code != 200:
  120.             raise KeeneticApiException(r.status_code, r.text)
  121.         return r.json()
  122.  
  123.  
  124. class KeeneticApiException(Exception):
  125.     def __init__(self, status_code: int, response_text: str):
  126.         self.status_code = status_code
  127.         self.response_text = response_text
  128.  
  129.  
  130. # def ():
  131.  
  132. def tty_parse_lines(lines :list):
  133.     parse_res=[]
  134.     has_ok=False
  135.  
  136.     for s in lines:
  137.         v=s.split(',')
  138.         v=[i.strip() for i in v]
  139.         prefix=v[0].split(':')
  140.         cmdname=""
  141.         cmdfirstv=""
  142.         if len(prefix)>1:
  143.             cmdname=prefix[0].strip()
  144.             cmdfirstv=prefix[1].strip()
  145.         info={"src":s,"cmd":cmdname,"first_val":cmdfirstv,"vals":v}
  146.         if s=="OK":
  147.             has_ok=True
  148.         parse_res+=[info]
  149.     return parse_res,has_ok
  150.  
  151.  
  152. class AvgMeter():
  153.     def __init__(self):
  154.         self.dload_global_timer=HiTimer()
  155.         self.dload_timer=HiTimer()
  156.         self.rx_timer=HiTimer()
  157.         self.dload_vals=[]
  158.         self.dload_global_sum=0
  159.         self.dload_global_count=0
  160.         self.rxbytes_start=0
  161.         self.rxbytes_cur=0
  162.         self.rxspeed=0
  163.  
  164.     def set_rxbytes(self,rxbytes):
  165.         if self.rxbytes_start==0:
  166.             self.rx_timer.start()
  167.             self.rxbytes_start=rxbytes
  168.             self.rxbytes_cur=self.rxbytes_start
  169.             self.rxspeed=0
  170.             return
  171.         elapsedSec=self.rx_timer.elapsedsec()
  172.         if elapsedSec>=1.3:
  173.             self.rxbytes_cur=rxbytes
  174.             self.rxspeed=self.rxbytes_cur-self.rxbytes_start
  175.             self.rxspeed=self.rxspeed/elapsedSec
  176.  
  177.         if elapsedSec>=3:
  178.             self.rx_timer.start()
  179.             self.rxbytes_start=rxbytes
  180.             self.rxbytes_cur=self.rxbytes_start
  181.  
  182.     def get_rx_speed_bytes(self):
  183.         return self.rxspeed
  184.  
  185.     def start_download_timer(self):
  186.         self.dload_timer.start() 
  187.         self.dload_vals=[]
  188.     def start_download_global_timer(self):
  189.         self.dload_global_timer.start()
  190.         self.dload_global_sum=0
  191.         self.dload_global_count=0
  192.     def add_download_val(self,dload_speed):
  193.         # elapsedSec=self.dload_timer.elapsedsec()
  194.         # print(f"{elapsedSec} {len(self.dload_vals)} {self.dload_vals}")
  195.         if len(self.dload_vals)>=7:
  196.             del self.dload_vals[0]
  197.         self.dload_vals+=[dload_speed]
  198.     def add_download_global_val(self,dload_speed):
  199.         if self.dload_global_count>=100:
  200.             self.dload_global_sum=0
  201.             self.dload_global_count=0
  202.         self.dload_global_sum+=dload_speed
  203.         self.dload_global_count+=1
  204.     def avg_download_speed(self):
  205.         # elapsedSec=self.dload_timer.elapsedsec()
  206.         avg=sum(self.dload_vals)
  207.         avg=avg/len(self.dload_vals)
  208.         # print(f"sum {avg}")
  209.         # avg=avg/elapsedSec
  210.         # if  elapsedSec>=12:
  211.         #     self.start_download_timer()
  212.         return avg
  213.     def avg_download_global_speed(self):
  214.         # elapsedSec=self.dload_global_timer.elapsedsec()
  215.         # avg=self.dload_global_sum/elapsedSec
  216.         avg=self.dload_global_sum/self.dload_global_count
  217.         return avg
  218.  
  219.  
  220. class MetrStat():
  221.     def __init__(self):
  222.         self.stats={}
  223.         self.count=0
  224.         self.reset()
  225.         self.reset_freq=35
  226.  
  227.     def reset(self):
  228.         self.stats={"qpsk":0,"16qam":0,"64qam":0,"256qam":0,"other":0}
  229.         self.count=0
  230.  
  231.     def add_val(self,stat_name,incr_val):
  232.         if self.count>self.reset_freq:
  233.             self.reset()
  234.         self.stats[stat_name]+=incr_val
  235.         self.count+=1
  236.  
  237.     def best_modulation(self):
  238.         best_stat=max(self.stats, key=self.stats.get)
  239.         max_val=self.stats[best_stat]
  240.         sum_all=self.stats["qpsk"]+self.stats["16qam"]+self.stats["64qam"]+self.stats["256qam"]+self.stats["other"]
  241.         percent=(max_val/sum_all)*100
  242.         return best_stat,max_val,percent
  243.  
  244.  
  245.  
  246. def router_info(kc :KeeneticClient,speedmeter :AvgMeter,stats :MetrStat):
  247. # def router_info(cfg):
  248.         # res=kc.do_get(f"/rci/show/interface",{}) #,{"":""})
  249.         # ipp=res["UsbLte0"]
  250.         # ## print(res)
  251.         # print(ipp)
  252.     # modem_ret=res["parse"]["status"]
  253.     # print(res)
  254.     # print(modem_ret)
  255.     # print(datetime.now())
  256.  
  257.     ireq={}
  258.     ireq["auth"]=True
  259.     ireq["tty_error"]=""
  260.     ireq["modem_error"]=""
  261.     ireq["errmsg"]=""
  262.  
  263.     res=kc.do_get(f"/rci/show/interface",{}) #,{"":""})
  264.     ipp=res["UsbLte0"]
  265.  
  266.     if ipp["link"]=="down" or  ipp["connected"]=="no":
  267.         ireq["modem_error"]="error"
  268.         ireq["errmsg"]=f"link {ipp["link"]} ,connected {ipp["connected"]}"
  269.         raise KeeneticApiException("901", ireq["errmsg"])
  270.  
  271.     #interface UsbLte0 tty send AT+GTCCINFO?
  272.     res=kc.do_post(f"/rci/",{"parse": "interface UsbLte0 tty send AT+GTCAINFO?"})
  273.     if res["parse"]["status"][0]["status"]=="error":
  274.         msg=res["parse"]["status"][0]["message"]
  275.         ireq["tty_error"]="error"
  276.         ireq["errmsg"]=msg
  277.         raise KeeneticApiException("910", ireq["errmsg"])
  278.     ca_res=res["parse"]["tty-out"]
  279.     ca_data,ca_has_ok=tty_parse_lines(ca_res)
  280.     # print(ca_res)
  281.     # print(ca_data)
  282.     """
  283.     PCC: <band>, <physical cellId>, <earfcn>, <dl_bandwidth>, ?     , <dl_mimo>, <ul_mimo>, <dl_modulation>, <ul_modulation>, <rsrp>
  284.     "PCC:  103 , 489              , 1275    , 75            , 75    , 1        , 1        , 2              , 3              , -64"
  285.  
  286.     (10 vals) "PCC:103,489,1275,75,75,1,1,2,3,-64" 
  287.      "PCC:103,489,1275,75,75,1,1,2,1,-64",
  288.      "PCC:103,489,1275,75,75,1,1,2,3,-64",
  289.      "PCC:103,489,1275,75,75,1,1,2,3,-64",
  290.      "PCC:107,427,2850,100,100,2,1,3,3,-81",
  291.  
  292.     SCC1: <scell_state>, <ul_configured>, <band>, <physical cellId>, <earfcn>, <dl_bandwidth>, <ul_bandwidth>, <dl_mimo>, <ul_mimo>, <dl_modulation>, <ul_modulation>, <rsrp>
  293.     (12 vals) 
  294.     "SCC 1:2           ,1               ,107    ,427               ,3048     ,100            ,100            ,2         ,1         ,3               ,3               ,-81",
  295.     "SCC 1:2,1,107,427,3048,100,100,1,1,3,1,-80",
  296.     "SCC 1:2,1,107,427,3048,100,100,2,1,3,3,-81",
  297.     """
  298.  
  299.  
  300.     #interface UsbLte0 tty send AT+CESQ
  301.     res=kc.do_post(f"/rci/",{"parse": "interface UsbLte0 tty send AT+CSQ"})
  302.     if res["parse"]["status"][0]["status"]=="error":
  303.         msg=res["parse"]["status"][0]["message"]
  304.         ireq["tty_error"]="error"
  305.         ireq["errmsg"]=msg
  306.         raise KeeneticApiException("910", ireq["errmsg"])
  307.     csq_res=res["parse"]["tty-out"]
  308.     csq_data,csq_has_ok=tty_parse_lines(csq_res)
  309.     # print(csq_res)
  310.     # print(csq_data)
  311.  
  312.     # ## print(res)
  313.     # print(ipp)
  314.     res=kc.do_post(f"/rci/",{"parse": "show interface UsbLte0 stat"})
  315.     speed_res=res["parse"]
  316.     rxbytes=speed_res["rxbytes"]
  317.     txbytes=speed_res["txbytes"]
  318.     rxspeed=speed_res["rxspeed"]
  319.     txspeed=speed_res["txspeed"]
  320.     # print(speed_res)
  321.     # print(rxspeed)
  322.     # print(txspeed)
  323.  
  324.  
  325.     ibs={}
  326.     ibs["datetime"]=datetime.now()
  327.     ibs["datetext"]=f"{datetime.now()}"
  328.     # 'sim': 'READY',
  329.     # 'operator-raw': '0,0,"MegaFon pre-5G",7',
  330.     # 'connection-state': 'Connected',
  331.     # 'state': 'up',
  332.     if ipp["connected"]=="yes":
  333.         ibs["mstate"]="connected"
  334.     else:
  335.         ibs["mstate"]="no connection"
  336.  
  337.     ibs["mlink"]=ipp["link"]
  338.  
  339.     ibs["t"]=ipp['temperature']
  340.     ibs["enbid"]=ipp['enb-id']
  341.     ibs["cell"]=ipp['bssid']
  342.     ibs["pci"]=ipp['phy-cell-id']
  343.     ibs["sector"]=ipp['sector-id']
  344.  
  345.     speedmeter.set_rxbytes(rxbytes)
  346.     avg_dspeed_bytes=speedmeter.get_rx_speed_bytes()
  347.  
  348.     speedmeter.add_download_val(rxspeed/1000000)
  349.     avg_dspeed=speedmeter.avg_download_speed()
  350.  
  351.     speedmeter.add_download_global_val(rxspeed/1000000)
  352.     avg_dspeed_global=speedmeter.avg_download_global_speed()
  353.  
  354.     ispeed={}
  355.     # ispeed["down"]=rxbytes #rxspeed
  356.     # ispeed["down"]=rxspeed
  357.     ispeed["down_quick"]=(avg_dspeed_bytes*8.0)/1000000.0 #avg_dspeed_bytes/(1000.0) # (avg_dspeed_bytes*8.0)/1000.0
  358.     ispeed["down"]=rxspeed/1000000
  359.     ispeed["up"]=txspeed/1000000
  360.     ispeed["avgtotal"]=avg_dspeed_global
  361.     ispeed["avglast"]=avg_dspeed
  362.     ispeed["ping"]="10"
  363.  
  364.     imetric={}
  365.     imetric["rsrq"]=ipp['rsrq']
  366.     imetric["rsrp"]=ipp['rsrp']
  367.     imetric["rssi"]=ipp['rssi']
  368.     imetric["sinr"]=ipp['cinr']
  369.     imetric["csq"]=csq_data[0]["first_val"]
  370.     imetric["signal-level"]=ipp["signal-level"]
  371.  
  372.  
  373.     icarrier={}
  374.     bands=[]
  375.     icarrier["bands"]=bands
  376.     for ca in ca_data:
  377.         if ca["cmd"]=="+GTCAINFO" or ca["src"]=="OK":
  378.             continue
  379.         offset=0
  380.         if ca["cmd"]=="PCC":
  381.             offset=0
  382.             bandnum=ca["first_val"]
  383.         else:
  384.             offset=2
  385.             bandnum=ca["vals"][offset]
  386.         bandnum=str(int(bandnum)-100)
  387.         band={}
  388.         band["name"]="Band "+bandnum
  389.         band["num"]=bandnum
  390.         band["pci"]=ca["vals"][1+offset]
  391.         modulation=ca["vals"][7+offset]
  392.         band["modulation"]="" #"QAM64"
  393.  
  394.         if modulation=="0":
  395.             band["modulation"]="BPSK"
  396.             stats.add_val("other",1)
  397.         elif modulation=="1":
  398.             band["modulation"]="QPSK"
  399.             stats.add_val("qpsk",1)
  400.         elif modulation=="2":
  401.             band["modulation"]="16QAM"
  402.             stats.add_val("16qam",1)
  403.         elif modulation=="3":
  404.             band["modulation"]="64QAM"
  405.             stats.add_val("64qam",1)
  406.         elif modulation=="4":
  407.             band["modulation"]="256QAM"
  408.             stats.add_val("256qam",1)
  409.         else:
  410.             band["modulation"]="U?"
  411.             stats.add_val("other",1)
  412.  
  413.         best_stat,max_val,percent=stats.best_modulation()
  414.         band["calc_modul_best"]=best_stat
  415.         band["calc_modul_percent"]=percent
  416.  
  417.         mimo=ca["vals"][5+offset]
  418.         band["mimo"]=""
  419.         if mimo=="1":
  420.             band["mimo"]="1x1"
  421.         elif mimo=="2":
  422.             band["mimo"]="2x2"
  423.         elif mimo=="3":
  424.             band["mimo"]="4x4"
  425.         band["rsrp"]=ca["vals"][9+offset]
  426.         bands+=[band]
  427.  
  428.  
  429.     return ireq,ibs,ispeed,imetric,icarrier
  430.  
  431. def update_ui(live_data :Live,layout :Layout,ireq,ibs,ispeed,imetric,icarrier):
  432.     # table = Table(box=None)  #(box=box.SQUARE,show_header=False) # box=None) #box.SQUARE)
  433.     table =Table.grid() #(expand=True)
  434.     table.add_column("1",width=40, justify="center")
  435.     table.add_column("2",width=30)
  436.     table.add_column("3",width=40)
  437.     # dt=f"{ibs["datetime"].second}" #.now().second}"
  438.     table.add_row(f'Cell =   [bold yellow]{ibs["enbid"]} : {ibs["cell"]}',f'PCI/sector = {ibs["pci"]} : {ibs["sector"]}')
  439.     state_data=f'[bold cyan] {ibs["mstate"].upper()}'
  440.     if ibs["mstate"]!="connected":
  441.         state_data=f'[bold red] {ibs["mstate"].upper()}'
  442.     table.add_row(state_data,f'T = [bold]{ibs["t"]}C', ibs["datetext"])
  443.     layout["row1"].update(table)
  444.     # layout["row1"].update(Panel(table))
  445.  
  446.     table = Table(box=None)
  447.     table.add_column("Download",width=27, justify="center")
  448.     table.add_column("Avg (last100/last10)",width=38, justify="center")
  449.     table.add_column("Upload",width=15, justify="center")
  450.     # table.add_row(end_section=True)
  451.     # dspeed=ispeed["down"]/1000000
  452.     # uspeed=ispeed["up"]/1000000
  453.     dspeed_quick=ispeed["down_quick"]
  454.     dspeed=ispeed["down"]
  455.     uspeed=ispeed["up"]
  456.     table.add_row(f"[bold bright_green]{dspeed:.2f} (quick: {dspeed_quick:.2f}) mbit",f"[bold cyan]{ispeed["avgtotal"]:.2f} / {ispeed["avglast"]:.2f} mbit",f"[bold orange1]{uspeed:.2f} mbit")
  457.     layout["row2"].update(Panel(table,box=box.ROUNDED,border_style="grey42"))
  458.  
  459.     table = Table(box=box.SQUARE) 
  460.     style_csq="bold red"
  461.     style_rsrq="bold"
  462.     style_rsrp="bold yellow"
  463.     style_rssi="bold bright_cyan"
  464.     style_sinr="bold green"
  465.     table.add_column("",width=10, justify="center")
  466.     table.add_column("",width=10, justify="center")
  467.     table.add_column("Signal-level",width=10, justify="center")
  468.     table.add_column("CSQ",width=10, justify="center",header_style=style_csq.replace("bold",""))
  469.     table.add_column("RSRQ",width=10, justify="center",header_style=style_rsrq.replace("bold",""))
  470.     table.add_column("RSRP",width=10, justify="center",header_style=style_rsrp.replace("bold",""))
  471.     table.add_column("RSSI",width=10, justify="center",header_style=style_rssi.replace("bold",""))
  472.     table.add_column("SINR",width=10, justify="center",header_style=style_sinr.replace("bold",""))
  473.     table.add_row("","",f"{imetric["signal-level"]}",f"[{style_csq}]{imetric["csq"]}",f"[{style_rsrq}]{imetric["rsrq"]}",f"[{style_rsrp}]{imetric["rsrp"]}",f"[{style_rssi}]{imetric["rssi"]}",f"[{style_sinr}]{imetric["sinr"]}")
  474.     layout["row3"].update(Panel(table,title="METRIC",title_align="left",box=box.ROUNDED,border_style="grey30"))
  475.  
  476.     table = Table(box=box.SQUARE,show_lines=True) 
  477.     table.add_column("Band",width=10, justify="center")
  478.     table.add_column("PCI",width=10, justify="center")
  479.     table.add_column("Modulation",width=22, justify="center")
  480.     table.add_column("Mimo",width=10, justify="center")
  481.     table.add_column("RSRP",width=10, justify="center",header_style=style_rsrp.replace("bold",""))
  482.     for ca in icarrier["bands"]:
  483.     # ca=icarrier["bands"][0]
  484.         modl=ca["modulation"]
  485.         modl_style=""
  486.         if modl=="QPSK":
  487.             modl_style="default"
  488.         elif modl=="16QAM":
  489.             modl_style="cyan"
  490.         elif modl=="64QAM":
  491.             modl_style="bold green"
  492.         elif modl=="256QAM":
  493.             modl_style="bold magenta"
  494.         else:
  495.             modl_style="bold yellow"
  496.  
  497.         mimo=ca["mimo"]
  498.         mimo_style=""
  499.         if mimo=="1x1":
  500.             mimo_style="default"
  501.         elif mimo=="2x2":
  502.             mimo_style="bold green"
  503.         elif mimo=="4x4":
  504.             mimo_style="bold magenta"
  505.         else:
  506.             mimo_style="bold yellow"
  507.         table.add_row(f"[bold bright_cyan]{ca["num"]}",f"{ca["pci"]}",f"[{modl_style}]{modl} ({ca['calc_modul_best']} {int(ca['calc_modul_percent'])}%)",f"[{mimo_style}]{ca["mimo"]}",f"[{style_rsrp}]{ca["rsrp"]}")
  508.  
  509.     layout["row4"].update(Panel(table,title="C A R R I E R    I N F O",title_align="left",box=box.ROUNDED,border_style="grey30"))
  510.     live_data.update(layout)
  511.  
  512.  
  513. def runmain():
  514.     # pwd = os.path.dirname(os.path.realpath(__file__))
  515.     # cfg = json.load(open(pwd + "mypass.json", "r"))
  516.     # logging.info("Connecting to router: " + keenetic_config['admin_endpoint'])
  517.  
  518.     pwd = os.path.dirname(os.path.realpath(__file__))
  519.     data=file_load(pwd +"\\mypass.json")
  520.     cfg =json.loads(data)
  521.     conn_info = cfg['info']
  522.     admin_endpoint="""http://192.168.1.1:80"""
  523.     login="admin"
  524.     password=conn_info['password']
  525.     # http://192.168.1.1/rci/show/interface
  526.     connect_tested=False
  527.  
  528.     speedmeter=AvgMeter()
  529.     stats=MetrStat()
  530.  
  531.     layout = Layout()
  532.     layout.split_column(
  533.         Layout(name="row1",size=2),
  534.         Layout(name="row2",size=4),
  535.         Layout(name="row3",size=7),
  536.         Layout(name="row4"), )
  537.  
  538.     state_code=0
  539.     while True:
  540.         # if state_code==503:
  541.         if state_code==-1:
  542.             break
  543.         try:
  544.             speedmeter.start_download_timer()
  545.             speedmeter.start_download_global_timer()
  546.             with KeeneticClient(admin_endpoint, False,login, password) as kc:
  547.                 if not connect_tested :
  548.                     kc.connect()
  549.                     connect_tested=True
  550.                     # print("connected")
  551.  
  552.                 with Live(layout) as live_data:
  553.                     for i in range(9666333):
  554.                     # for i in range(5):
  555.                         ireq,ibs,ispeed,imetric,icarrier=router_info(kc,speedmeter,stats)
  556.                         update_ui(live_data,layout,ireq,ibs,ispeed,imetric,icarrier)
  557.                         # print(ibs)
  558.                         # print(ispeed)
  559.                         # print(imetric)
  560.                         # print(icarrier)
  561.                         time.sleep(0.25)
  562.         except ConnectionError as e:
  563.             print(f"connection error: {e}")        
  564.             print("restarting...")
  565.             state_code=404
  566.         except KeeneticApiException as e:
  567.             print(f"my keenetic error: {e}")        
  568.             if e.status_code==503:
  569.                 print("503 - restarting...")
  570.             else:
  571.                 print(f"{e.status_code} - restarting...")
  572.             state_code=901
  573.         except Exception as e:
  574.             print(f"unknown error: {e}")        
  575.             state_code=10
  576.         finally:
  577.             pass
  578.         time.sleep(2)
  579.  
  580.  
  581.  
  582. if __name__ == '__main__':
  583.     runmain()
  584.     try:
  585.         pass
  586.     finally:
  587.         pass
  588.  
  589.  
  590.  
  591.  
  592.  
Success #stdin #stdout 0.01s 7024KB
comments ()
stdin 
Standard input is empty
stdout 
1
https://ideone.com/KsRWCW
language:
Python (cpython 2.7.16)
created:
5 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!