| # |
| # Autogenerated by Thrift Compiler (0.10.0) |
| # |
| # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| # |
| # options string: py |
| # |
| |
| from thrift.Thrift import TType, TMessageType, TFrozenDict, TException, TApplicationException |
| from thrift.protocol.TProtocol import TProtocolException |
| import sys |
| import logging |
| from .ttypes import * |
| from thrift.Thrift import TProcessor |
| from thrift.transport import TTransport |
| |
| |
| class Iface(object): |
| def pltfm_pm_port_add(self, device, dev_port, ps, fec): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| - ps |
| - fec |
| """ |
| pass |
| |
| def pltfm_pm_port_del(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| pass |
| |
| def pltfm_pm_port_enable(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| pass |
| |
| def pltfm_pm_port_dis(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| pass |
| |
| def pltfm_pm_switchd_port_cleanup(self, device): |
| """ |
| Parameters: |
| - device |
| """ |
| pass |
| |
| def pltfm_pm_port_oper_status_get(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| pass |
| |
| def pltfm_pm_board_type_get(self): |
| pass |
| |
| def pltfm_pm_port_an_set(self, device, dev_port, an_flag): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| - an_flag |
| """ |
| pass |
| |
| def pltfm_pm_serdes_lane_map_set(self, device): |
| """ |
| Parameters: |
| - device |
| """ |
| pass |
| |
| def pltfm_pm_serdes_init(self, device): |
| """ |
| Parameters: |
| - device |
| """ |
| pass |
| |
| |
| class Client(Iface): |
| def __init__(self, iprot, oprot=None): |
| self._iprot = self._oprot = iprot |
| if oprot is not None: |
| self._oprot = oprot |
| self._seqid = 0 |
| |
| def pltfm_pm_port_add(self, device, dev_port, ps, fec): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| - ps |
| - fec |
| """ |
| self.send_pltfm_pm_port_add(device, dev_port, ps, fec) |
| return self.recv_pltfm_pm_port_add() |
| |
| def send_pltfm_pm_port_add(self, device, dev_port, ps, fec): |
| self._oprot.writeMessageBegin('pltfm_pm_port_add', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_port_add_args() |
| args.device = device |
| args.dev_port = dev_port |
| args.ps = ps |
| args.fec = fec |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_port_add(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_port_add_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_port_add failed: unknown result") |
| |
| def pltfm_pm_port_del(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| self.send_pltfm_pm_port_del(device, dev_port) |
| return self.recv_pltfm_pm_port_del() |
| |
| def send_pltfm_pm_port_del(self, device, dev_port): |
| self._oprot.writeMessageBegin('pltfm_pm_port_del', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_port_del_args() |
| args.device = device |
| args.dev_port = dev_port |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_port_del(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_port_del_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_port_del failed: unknown result") |
| |
| def pltfm_pm_port_enable(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| self.send_pltfm_pm_port_enable(device, dev_port) |
| return self.recv_pltfm_pm_port_enable() |
| |
| def send_pltfm_pm_port_enable(self, device, dev_port): |
| self._oprot.writeMessageBegin('pltfm_pm_port_enable', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_port_enable_args() |
| args.device = device |
| args.dev_port = dev_port |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_port_enable(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_port_enable_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_port_enable failed: unknown result") |
| |
| def pltfm_pm_port_dis(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| self.send_pltfm_pm_port_dis(device, dev_port) |
| return self.recv_pltfm_pm_port_dis() |
| |
| def send_pltfm_pm_port_dis(self, device, dev_port): |
| self._oprot.writeMessageBegin('pltfm_pm_port_dis', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_port_dis_args() |
| args.device = device |
| args.dev_port = dev_port |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_port_dis(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_port_dis_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_port_dis failed: unknown result") |
| |
| def pltfm_pm_switchd_port_cleanup(self, device): |
| """ |
| Parameters: |
| - device |
| """ |
| self.send_pltfm_pm_switchd_port_cleanup(device) |
| return self.recv_pltfm_pm_switchd_port_cleanup() |
| |
| def send_pltfm_pm_switchd_port_cleanup(self, device): |
| self._oprot.writeMessageBegin('pltfm_pm_switchd_port_cleanup', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_switchd_port_cleanup_args() |
| args.device = device |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_switchd_port_cleanup(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_switchd_port_cleanup_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_switchd_port_cleanup failed: unknown result") |
| |
| def pltfm_pm_port_oper_status_get(self, device, dev_port): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| """ |
| self.send_pltfm_pm_port_oper_status_get(device, dev_port) |
| return self.recv_pltfm_pm_port_oper_status_get() |
| |
| def send_pltfm_pm_port_oper_status_get(self, device, dev_port): |
| self._oprot.writeMessageBegin('pltfm_pm_port_oper_status_get', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_port_oper_status_get_args() |
| args.device = device |
| args.dev_port = dev_port |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_port_oper_status_get(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_port_oper_status_get_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_port_oper_status_get failed: unknown result") |
| |
| def pltfm_pm_board_type_get(self): |
| self.send_pltfm_pm_board_type_get() |
| return self.recv_pltfm_pm_board_type_get() |
| |
| def send_pltfm_pm_board_type_get(self): |
| self._oprot.writeMessageBegin('pltfm_pm_board_type_get', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_board_type_get_args() |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_board_type_get(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_board_type_get_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_board_type_get failed: unknown result") |
| |
| def pltfm_pm_port_an_set(self, device, dev_port, an_flag): |
| """ |
| Parameters: |
| - device |
| - dev_port |
| - an_flag |
| """ |
| self.send_pltfm_pm_port_an_set(device, dev_port, an_flag) |
| return self.recv_pltfm_pm_port_an_set() |
| |
| def send_pltfm_pm_port_an_set(self, device, dev_port, an_flag): |
| self._oprot.writeMessageBegin('pltfm_pm_port_an_set', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_port_an_set_args() |
| args.device = device |
| args.dev_port = dev_port |
| args.an_flag = an_flag |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_port_an_set(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_port_an_set_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_port_an_set failed: unknown result") |
| |
| def pltfm_pm_serdes_lane_map_set(self, device): |
| """ |
| Parameters: |
| - device |
| """ |
| self.send_pltfm_pm_serdes_lane_map_set(device) |
| return self.recv_pltfm_pm_serdes_lane_map_set() |
| |
| def send_pltfm_pm_serdes_lane_map_set(self, device): |
| self._oprot.writeMessageBegin('pltfm_pm_serdes_lane_map_set', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_serdes_lane_map_set_args() |
| args.device = device |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_serdes_lane_map_set(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_serdes_lane_map_set_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_serdes_lane_map_set failed: unknown result") |
| |
| def pltfm_pm_serdes_init(self, device): |
| """ |
| Parameters: |
| - device |
| """ |
| self.send_pltfm_pm_serdes_init(device) |
| return self.recv_pltfm_pm_serdes_init() |
| |
| def send_pltfm_pm_serdes_init(self, device): |
| self._oprot.writeMessageBegin('pltfm_pm_serdes_init', TMessageType.CALL, self._seqid) |
| args = pltfm_pm_serdes_init_args() |
| args.device = device |
| args.write(self._oprot) |
| self._oprot.writeMessageEnd() |
| self._oprot.trans.flush() |
| |
| def recv_pltfm_pm_serdes_init(self): |
| iprot = self._iprot |
| (fname, mtype, rseqid) = iprot.readMessageBegin() |
| if mtype == TMessageType.EXCEPTION: |
| x = TApplicationException() |
| x.read(iprot) |
| iprot.readMessageEnd() |
| raise x |
| result = pltfm_pm_serdes_init_result() |
| result.read(iprot) |
| iprot.readMessageEnd() |
| if result.success is not None: |
| return result.success |
| if result.ouch is not None: |
| raise result.ouch |
| raise TApplicationException(TApplicationException.MISSING_RESULT, "pltfm_pm_serdes_init failed: unknown result") |
| |
| |
| class Processor(Iface, TProcessor): |
| def __init__(self, handler): |
| self._handler = handler |
| self._processMap = {} |
| self._processMap["pltfm_pm_port_add"] = Processor.process_pltfm_pm_port_add |
| self._processMap["pltfm_pm_port_del"] = Processor.process_pltfm_pm_port_del |
| self._processMap["pltfm_pm_port_enable"] = Processor.process_pltfm_pm_port_enable |
| self._processMap["pltfm_pm_port_dis"] = Processor.process_pltfm_pm_port_dis |
| self._processMap["pltfm_pm_switchd_port_cleanup"] = Processor.process_pltfm_pm_switchd_port_cleanup |
| self._processMap["pltfm_pm_port_oper_status_get"] = Processor.process_pltfm_pm_port_oper_status_get |
| self._processMap["pltfm_pm_board_type_get"] = Processor.process_pltfm_pm_board_type_get |
| self._processMap["pltfm_pm_port_an_set"] = Processor.process_pltfm_pm_port_an_set |
| self._processMap["pltfm_pm_serdes_lane_map_set"] = Processor.process_pltfm_pm_serdes_lane_map_set |
| self._processMap["pltfm_pm_serdes_init"] = Processor.process_pltfm_pm_serdes_init |
| |
| def process(self, iprot, oprot): |
| (name, type, seqid) = iprot.readMessageBegin() |
| if name not in self._processMap: |
| iprot.skip(TType.STRUCT) |
| iprot.readMessageEnd() |
| x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name)) |
| oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid) |
| x.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| return |
| else: |
| self._processMap[name](self, seqid, iprot, oprot) |
| return True |
| |
| def process_pltfm_pm_port_add(self, seqid, iprot, oprot): |
| args = pltfm_pm_port_add_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_port_add_result() |
| try: |
| result.success = self._handler.pltfm_pm_port_add(args.device, args.dev_port, args.ps, args.fec) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_port_add", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_port_del(self, seqid, iprot, oprot): |
| args = pltfm_pm_port_del_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_port_del_result() |
| try: |
| result.success = self._handler.pltfm_pm_port_del(args.device, args.dev_port) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_port_del", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_port_enable(self, seqid, iprot, oprot): |
| args = pltfm_pm_port_enable_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_port_enable_result() |
| try: |
| result.success = self._handler.pltfm_pm_port_enable(args.device, args.dev_port) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_port_enable", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_port_dis(self, seqid, iprot, oprot): |
| args = pltfm_pm_port_dis_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_port_dis_result() |
| try: |
| result.success = self._handler.pltfm_pm_port_dis(args.device, args.dev_port) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_port_dis", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_switchd_port_cleanup(self, seqid, iprot, oprot): |
| args = pltfm_pm_switchd_port_cleanup_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_switchd_port_cleanup_result() |
| try: |
| result.success = self._handler.pltfm_pm_switchd_port_cleanup(args.device) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_switchd_port_cleanup", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_port_oper_status_get(self, seqid, iprot, oprot): |
| args = pltfm_pm_port_oper_status_get_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_port_oper_status_get_result() |
| try: |
| result.success = self._handler.pltfm_pm_port_oper_status_get(args.device, args.dev_port) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_port_oper_status_get", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_board_type_get(self, seqid, iprot, oprot): |
| args = pltfm_pm_board_type_get_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_board_type_get_result() |
| try: |
| result.success = self._handler.pltfm_pm_board_type_get() |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_board_type_get", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_port_an_set(self, seqid, iprot, oprot): |
| args = pltfm_pm_port_an_set_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_port_an_set_result() |
| try: |
| result.success = self._handler.pltfm_pm_port_an_set(args.device, args.dev_port, args.an_flag) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_port_an_set", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_serdes_lane_map_set(self, seqid, iprot, oprot): |
| args = pltfm_pm_serdes_lane_map_set_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_serdes_lane_map_set_result() |
| try: |
| result.success = self._handler.pltfm_pm_serdes_lane_map_set(args.device) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_serdes_lane_map_set", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| def process_pltfm_pm_serdes_init(self, seqid, iprot, oprot): |
| args = pltfm_pm_serdes_init_args() |
| args.read(iprot) |
| iprot.readMessageEnd() |
| result = pltfm_pm_serdes_init_result() |
| try: |
| result.success = self._handler.pltfm_pm_serdes_init(args.device) |
| msg_type = TMessageType.REPLY |
| except (TTransport.TTransportException, KeyboardInterrupt, SystemExit): |
| raise |
| except InvalidPltfmPmOperation as ouch: |
| msg_type = TMessageType.REPLY |
| result.ouch = ouch |
| except Exception as ex: |
| msg_type = TMessageType.EXCEPTION |
| logging.exception(ex) |
| result = TApplicationException(TApplicationException.INTERNAL_ERROR, 'Internal error') |
| oprot.writeMessageBegin("pltfm_pm_serdes_init", msg_type, seqid) |
| result.write(oprot) |
| oprot.writeMessageEnd() |
| oprot.trans.flush() |
| |
| # HELPER FUNCTIONS AND STRUCTURES |
| |
| |
| class pltfm_pm_port_add_args(object): |
| """ |
| Attributes: |
| - device |
| - dev_port |
| - ps |
| - fec |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| (2, TType.I32, 'dev_port', None, None, ), # 2 |
| (3, TType.I32, 'ps', None, None, ), # 3 |
| (4, TType.I32, 'fec', None, None, ), # 4 |
| ) |
| |
| def __init__(self, device=None, dev_port=None, ps=None, fec=None,): |
| self.device = device |
| self.dev_port = dev_port |
| self.ps = ps |
| self.fec = fec |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.dev_port = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.I32: |
| self.ps = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 4: |
| if ftype == TType.I32: |
| self.fec = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_add_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| if self.dev_port is not None: |
| oprot.writeFieldBegin('dev_port', TType.I32, 2) |
| oprot.writeI32(self.dev_port) |
| oprot.writeFieldEnd() |
| if self.ps is not None: |
| oprot.writeFieldBegin('ps', TType.I32, 3) |
| oprot.writeI32(self.ps) |
| oprot.writeFieldEnd() |
| if self.fec is not None: |
| oprot.writeFieldBegin('fec', TType.I32, 4) |
| oprot.writeI32(self.fec) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_add_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_add_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_del_args(object): |
| """ |
| Attributes: |
| - device |
| - dev_port |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| (2, TType.I32, 'dev_port', None, None, ), # 2 |
| ) |
| |
| def __init__(self, device=None, dev_port=None,): |
| self.device = device |
| self.dev_port = dev_port |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.dev_port = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_del_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| if self.dev_port is not None: |
| oprot.writeFieldBegin('dev_port', TType.I32, 2) |
| oprot.writeI32(self.dev_port) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_del_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_del_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_enable_args(object): |
| """ |
| Attributes: |
| - device |
| - dev_port |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| (2, TType.I32, 'dev_port', None, None, ), # 2 |
| ) |
| |
| def __init__(self, device=None, dev_port=None,): |
| self.device = device |
| self.dev_port = dev_port |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.dev_port = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_enable_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| if self.dev_port is not None: |
| oprot.writeFieldBegin('dev_port', TType.I32, 2) |
| oprot.writeI32(self.dev_port) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_enable_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_enable_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_dis_args(object): |
| """ |
| Attributes: |
| - device |
| - dev_port |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| (2, TType.I32, 'dev_port', None, None, ), # 2 |
| ) |
| |
| def __init__(self, device=None, dev_port=None,): |
| self.device = device |
| self.dev_port = dev_port |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.dev_port = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_dis_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| if self.dev_port is not None: |
| oprot.writeFieldBegin('dev_port', TType.I32, 2) |
| oprot.writeI32(self.dev_port) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_dis_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_dis_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_switchd_port_cleanup_args(object): |
| """ |
| Attributes: |
| - device |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| ) |
| |
| def __init__(self, device=None,): |
| self.device = device |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_switchd_port_cleanup_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_switchd_port_cleanup_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_switchd_port_cleanup_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_oper_status_get_args(object): |
| """ |
| Attributes: |
| - device |
| - dev_port |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| (2, TType.I32, 'dev_port', None, None, ), # 2 |
| ) |
| |
| def __init__(self, device=None, dev_port=None,): |
| self.device = device |
| self.dev_port = dev_port |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.dev_port = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_oper_status_get_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| if self.dev_port is not None: |
| oprot.writeFieldBegin('dev_port', TType.I32, 2) |
| oprot.writeI32(self.dev_port) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_oper_status_get_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_oper_status_get_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_board_type_get_args(object): |
| |
| thrift_spec = ( |
| ) |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_board_type_get_args') |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_board_type_get_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_board_type_get_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_an_set_args(object): |
| """ |
| Attributes: |
| - device |
| - dev_port |
| - an_flag |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| (2, TType.I32, 'dev_port', None, None, ), # 2 |
| (3, TType.I32, 'an_flag', None, None, ), # 3 |
| ) |
| |
| def __init__(self, device=None, dev_port=None, an_flag=None,): |
| self.device = device |
| self.dev_port = dev_port |
| self.an_flag = an_flag |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| elif fid == 2: |
| if ftype == TType.I32: |
| self.dev_port = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 3: |
| if ftype == TType.I32: |
| self.an_flag = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_an_set_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| if self.dev_port is not None: |
| oprot.writeFieldBegin('dev_port', TType.I32, 2) |
| oprot.writeI32(self.dev_port) |
| oprot.writeFieldEnd() |
| if self.an_flag is not None: |
| oprot.writeFieldBegin('an_flag', TType.I32, 3) |
| oprot.writeI32(self.an_flag) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_port_an_set_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_port_an_set_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_serdes_lane_map_set_args(object): |
| """ |
| Attributes: |
| - device |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| ) |
| |
| def __init__(self, device=None,): |
| self.device = device |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_serdes_lane_map_set_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_serdes_lane_map_set_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_serdes_lane_map_set_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_serdes_init_args(object): |
| """ |
| Attributes: |
| - device |
| """ |
| |
| thrift_spec = ( |
| None, # 0 |
| (1, TType.BYTE, 'device', None, None, ), # 1 |
| ) |
| |
| def __init__(self, device=None,): |
| self.device = device |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 1: |
| if ftype == TType.BYTE: |
| self.device = iprot.readByte() |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_serdes_init_args') |
| if self.device is not None: |
| oprot.writeFieldBegin('device', TType.BYTE, 1) |
| oprot.writeByte(self.device) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |
| |
| |
| class pltfm_pm_serdes_init_result(object): |
| """ |
| Attributes: |
| - success |
| - ouch |
| """ |
| |
| thrift_spec = ( |
| (0, TType.I32, 'success', None, None, ), # 0 |
| (1, TType.STRUCT, 'ouch', (InvalidPltfmPmOperation, InvalidPltfmPmOperation.thrift_spec), None, ), # 1 |
| ) |
| |
| def __init__(self, success=None, ouch=None,): |
| self.success = success |
| self.ouch = ouch |
| |
| def read(self, iprot): |
| if iprot._fast_decode is not None and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None: |
| iprot._fast_decode(self, iprot, (self.__class__, self.thrift_spec)) |
| return |
| iprot.readStructBegin() |
| while True: |
| (fname, ftype, fid) = iprot.readFieldBegin() |
| if ftype == TType.STOP: |
| break |
| if fid == 0: |
| if ftype == TType.I32: |
| self.success = iprot.readI32() |
| else: |
| iprot.skip(ftype) |
| elif fid == 1: |
| if ftype == TType.STRUCT: |
| self.ouch = InvalidPltfmPmOperation() |
| self.ouch.read(iprot) |
| else: |
| iprot.skip(ftype) |
| else: |
| iprot.skip(ftype) |
| iprot.readFieldEnd() |
| iprot.readStructEnd() |
| |
| def write(self, oprot): |
| if oprot._fast_encode is not None and self.thrift_spec is not None: |
| oprot.trans.write(oprot._fast_encode(self, (self.__class__, self.thrift_spec))) |
| return |
| oprot.writeStructBegin('pltfm_pm_serdes_init_result') |
| if self.success is not None: |
| oprot.writeFieldBegin('success', TType.I32, 0) |
| oprot.writeI32(self.success) |
| oprot.writeFieldEnd() |
| if self.ouch is not None: |
| oprot.writeFieldBegin('ouch', TType.STRUCT, 1) |
| self.ouch.write(oprot) |
| oprot.writeFieldEnd() |
| oprot.writeFieldStop() |
| oprot.writeStructEnd() |
| |
| def validate(self): |
| return |
| |
| def __repr__(self): |
| L = ['%s=%r' % (key, value) |
| for key, value in self.__dict__.items()] |
| return '%s(%s)' % (self.__class__.__name__, ', '.join(L)) |
| |
| def __eq__(self, other): |
| return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ |
| |
| def __ne__(self, other): |
| return not (self == other) |