awx-zipline-ai 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

{ai/chronon → gen_thrift}/observability/ttypes.py

@@ -12,7 +12,7 @@ from thrift.TRecursive import fix_spec
 from uuid import UUID
 
 import sys
-import ai.chronon.api.common.ttypes
+import gen_thrift.common.ttypes
 
 from thrift.transport import TTransport
 all_structs = []
@@ -64,7 +64,19 @@ class DriftMetric(object):
     }
 
 
-class TileKey(object):
+class TileStatsType(object):
+    NULL_COUNTS = 1
+
+    _VALUES_TO_NAMES = {
+        1: "NULL_COUNTS",
+    }
+
+    _NAMES_TO_VALUES = {
+        "NULL_COUNTS": 1,
+    }
+
+
+class TileSummaryKey(object):
     """
     Attributes:
      - column
@@ -121,7 +133,7 @@ class TileKey(object):
         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('TileKey')
+        oprot.writeStructBegin('TileSummaryKey')
         if self.column is not None:
             oprot.writeFieldBegin('column', TType.STRING, 1)
             oprot.writeString(self.column.encode('utf-8') if sys.version_info[0] == 2 else self.column)
@@ -418,6 +430,146 @@ class TileSeriesKey(object):
         return not (self == other)
 
 
+class NullCounts(object):
+    """
+    Attributes:
+     - nullCounts
+     - rowCount
+
+    """
+    thrift_spec = None
+
+
+    def __init__(self, nullCounts = None, rowCount = None,):
+        self.nullCounts = nullCounts
+        self.rowCount = rowCount
+
+    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.MAP:
+                    self.nullCounts = {}
+                    (_ktype31, _vtype32, _size30) = iprot.readMapBegin()
+                    for _i34 in range(_size30):
+                        _key35 = iprot.readI32()
+                        _val36 = iprot.readI64()
+                        self.nullCounts[_key35] = _val36
+                    iprot.readMapEnd()
+                else:
+                    iprot.skip(ftype)
+            elif fid == 2:
+                if ftype == TType.I64:
+                    self.rowCount = iprot.readI64()
+                else:
+                    iprot.skip(ftype)
+            else:
+                iprot.skip(ftype)
+            iprot.readFieldEnd()
+        iprot.readStructEnd()
+
+    def write(self, oprot):
+        self.validate()
+        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('NullCounts')
+        if self.nullCounts is not None:
+            oprot.writeFieldBegin('nullCounts', TType.MAP, 1)
+            oprot.writeMapBegin(TType.I32, TType.I64, len(self.nullCounts))
+            for kiter37, viter38 in self.nullCounts.items():
+                oprot.writeI32(kiter37)
+                oprot.writeI64(viter38)
+            oprot.writeMapEnd()
+            oprot.writeFieldEnd()
+        if self.rowCount is not None:
+            oprot.writeFieldBegin('rowCount', TType.I64, 2)
+            oprot.writeI64(self.rowCount)
+            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 TileStats(object):
+    """
+    Attributes:
+     - nullCounts
+
+    """
+    thrift_spec = None
+
+
+    def __init__(self, nullCounts = None,):
+        self.nullCounts = nullCounts
+
+    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.STRUCT:
+                    self.nullCounts = NullCounts()
+                    self.nullCounts.read(iprot)
+                else:
+                    iprot.skip(ftype)
+            else:
+                iprot.skip(ftype)
+            iprot.readFieldEnd()
+        iprot.readStructEnd()
+
+    def write(self, oprot):
+        self.validate()
+        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('TileStats')
+        if self.nullCounts is not None:
+            oprot.writeFieldBegin('nullCounts', TType.STRUCT, 1)
+            self.nullCounts.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 TileSummarySeries(object):
     """
     Attributes:
@@ -460,117 +612,117 @@ class TileSummarySeries(object):
             if fid == 1:
                 if ftype == TType.LIST:
                     self.percentiles = []
-                    (_etype33, _size30) = iprot.readListBegin()
-                    for _i34 in range(_size30):
-                        _elem35 = []
-                        (_etype39, _size36) = iprot.readListBegin()
-                        for _i40 in range(_size36):
-                            _elem41 = iprot.readDouble()
-                            _elem35.append(_elem41)
+                    (_etype42, _size39) = iprot.readListBegin()
+                    for _i43 in range(_size39):
+                        _elem44 = []
+                        (_etype48, _size45) = iprot.readListBegin()
+                        for _i49 in range(_size45):
+                            _elem50 = iprot.readDouble()
+                            _elem44.append(_elem50)
                         iprot.readListEnd()
-                        self.percentiles.append(_elem35)
+                        self.percentiles.append(_elem44)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 2:
                 if ftype == TType.MAP:
                     self.histogram = {}
-                    (_ktype43, _vtype44, _size42) = iprot.readMapBegin()
-                    for _i46 in range(_size42):
-                        _key47 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        _val48 = []
-                        (_etype52, _size49) = iprot.readListBegin()
-                        for _i53 in range(_size49):
-                            _elem54 = iprot.readI64()
-                            _val48.append(_elem54)
+                    (_ktype52, _vtype53, _size51) = iprot.readMapBegin()
+                    for _i55 in range(_size51):
+                        _key56 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        _val57 = []
+                        (_etype61, _size58) = iprot.readListBegin()
+                        for _i62 in range(_size58):
+                            _elem63 = iprot.readI64()
+                            _val57.append(_elem63)
                         iprot.readListEnd()
-                        self.histogram[_key47] = _val48
+                        self.histogram[_key56] = _val57
                     iprot.readMapEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 3:
                 if ftype == TType.LIST:
                     self.count = []
-                    (_etype58, _size55) = iprot.readListBegin()
-                    for _i59 in range(_size55):
-                        _elem60 = iprot.readI64()
-                        self.count.append(_elem60)
+                    (_etype67, _size64) = iprot.readListBegin()
+                    for _i68 in range(_size64):
+                        _elem69 = iprot.readI64()
+                        self.count.append(_elem69)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 4:
                 if ftype == TType.LIST:
                     self.nullCount = []
-                    (_etype64, _size61) = iprot.readListBegin()
-                    for _i65 in range(_size61):
-                        _elem66 = iprot.readI64()
-                        self.nullCount.append(_elem66)
+                    (_etype73, _size70) = iprot.readListBegin()
+                    for _i74 in range(_size70):
+                        _elem75 = iprot.readI64()
+                        self.nullCount.append(_elem75)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 5:
                 if ftype == TType.LIST:
                     self.innerCount = []
-                    (_etype70, _size67) = iprot.readListBegin()
-                    for _i71 in range(_size67):
-                        _elem72 = iprot.readI64()
-                        self.innerCount.append(_elem72)
+                    (_etype79, _size76) = iprot.readListBegin()
+                    for _i80 in range(_size76):
+                        _elem81 = iprot.readI64()
+                        self.innerCount.append(_elem81)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 6:
                 if ftype == TType.LIST:
                     self.innerNullCount = []
-                    (_etype76, _size73) = iprot.readListBegin()
-                    for _i77 in range(_size73):
-                        _elem78 = iprot.readI64()
-                        self.innerNullCount.append(_elem78)
+                    (_etype85, _size82) = iprot.readListBegin()
+                    for _i86 in range(_size82):
+                        _elem87 = iprot.readI64()
+                        self.innerNullCount.append(_elem87)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 7:
                 if ftype == TType.LIST:
                     self.lengthPercentiles = []
-                    (_etype82, _size79) = iprot.readListBegin()
-                    for _i83 in range(_size79):
-                        _elem84 = []
-                        (_etype88, _size85) = iprot.readListBegin()
-                        for _i89 in range(_size85):
-                            _elem90 = iprot.readI32()
-                            _elem84.append(_elem90)
+                    (_etype91, _size88) = iprot.readListBegin()
+                    for _i92 in range(_size88):
+                        _elem93 = []
+                        (_etype97, _size94) = iprot.readListBegin()
+                        for _i98 in range(_size94):
+                            _elem99 = iprot.readI32()
+                            _elem93.append(_elem99)
                         iprot.readListEnd()
-                        self.lengthPercentiles.append(_elem84)
+                        self.lengthPercentiles.append(_elem93)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 8:
                 if ftype == TType.LIST:
                     self.stringLengthPercentiles = []
-                    (_etype94, _size91) = iprot.readListBegin()
-                    for _i95 in range(_size91):
-                        _elem96 = []
-                        (_etype100, _size97) = iprot.readListBegin()
-                        for _i101 in range(_size97):
-                            _elem102 = iprot.readI32()
-                            _elem96.append(_elem102)
+                    (_etype103, _size100) = iprot.readListBegin()
+                    for _i104 in range(_size100):
+                        _elem105 = []
+                        (_etype109, _size106) = iprot.readListBegin()
+                        for _i110 in range(_size106):
+                            _elem111 = iprot.readI32()
+                            _elem105.append(_elem111)
                         iprot.readListEnd()
-                        self.stringLengthPercentiles.append(_elem96)
+                        self.stringLengthPercentiles.append(_elem105)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 200:
                 if ftype == TType.LIST:
                     self.timestamps = []
-                    (_etype106, _size103) = iprot.readListBegin()
-                    for _i107 in range(_size103):
-                        _elem108 = iprot.readI64()
-                        self.timestamps.append(_elem108)
+                    (_etype115, _size112) = iprot.readListBegin()
+                    for _i116 in range(_size112):
+                        _elem117 = iprot.readI64()
+                        self.timestamps.append(_elem117)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 300:
                 if ftype == TType.STRUCT:
-                    self.key = TileSeriesKey()
+                    self.key = TileSummaryKey()
                     self.key.read(iprot)
                 else:
                     iprot.skip(ftype)
@@ -588,77 +740,77 @@ class TileSummarySeries(object):
         if self.percentiles is not None:
             oprot.writeFieldBegin('percentiles', TType.LIST, 1)
             oprot.writeListBegin(TType.LIST, len(self.percentiles))
-            for iter109 in self.percentiles:
-                oprot.writeListBegin(TType.DOUBLE, len(iter109))
-                for iter110 in iter109:
-                    oprot.writeDouble(iter110)
+            for iter118 in self.percentiles:
+                oprot.writeListBegin(TType.DOUBLE, len(iter118))
+                for iter119 in iter118:
+                    oprot.writeDouble(iter119)
                 oprot.writeListEnd()
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.histogram is not None:
             oprot.writeFieldBegin('histogram', TType.MAP, 2)
             oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.histogram))
-            for kiter111, viter112 in self.histogram.items():
-                oprot.writeString(kiter111.encode('utf-8') if sys.version_info[0] == 2 else kiter111)
-                oprot.writeListBegin(TType.I64, len(viter112))
-                for iter113 in viter112:
-                    oprot.writeI64(iter113)
+            for kiter120, viter121 in self.histogram.items():
+                oprot.writeString(kiter120.encode('utf-8') if sys.version_info[0] == 2 else kiter120)
+                oprot.writeListBegin(TType.I64, len(viter121))
+                for iter122 in viter121:
+                    oprot.writeI64(iter122)
                 oprot.writeListEnd()
             oprot.writeMapEnd()
             oprot.writeFieldEnd()
         if self.count is not None:
             oprot.writeFieldBegin('count', TType.LIST, 3)
             oprot.writeListBegin(TType.I64, len(self.count))
-            for iter114 in self.count:
-                oprot.writeI64(iter114)
+            for iter123 in self.count:
+                oprot.writeI64(iter123)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.nullCount is not None:
             oprot.writeFieldBegin('nullCount', TType.LIST, 4)
             oprot.writeListBegin(TType.I64, len(self.nullCount))
-            for iter115 in self.nullCount:
-                oprot.writeI64(iter115)
+            for iter124 in self.nullCount:
+                oprot.writeI64(iter124)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.innerCount is not None:
             oprot.writeFieldBegin('innerCount', TType.LIST, 5)
             oprot.writeListBegin(TType.I64, len(self.innerCount))
-            for iter116 in self.innerCount:
-                oprot.writeI64(iter116)
+            for iter125 in self.innerCount:
+                oprot.writeI64(iter125)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.innerNullCount is not None:
             oprot.writeFieldBegin('innerNullCount', TType.LIST, 6)
             oprot.writeListBegin(TType.I64, len(self.innerNullCount))
-            for iter117 in self.innerNullCount:
-                oprot.writeI64(iter117)
+            for iter126 in self.innerNullCount:
+                oprot.writeI64(iter126)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.lengthPercentiles is not None:
             oprot.writeFieldBegin('lengthPercentiles', TType.LIST, 7)
             oprot.writeListBegin(TType.LIST, len(self.lengthPercentiles))
-            for iter118 in self.lengthPercentiles:
-                oprot.writeListBegin(TType.I32, len(iter118))
-                for iter119 in iter118:
-                    oprot.writeI32(iter119)
+            for iter127 in self.lengthPercentiles:
+                oprot.writeListBegin(TType.I32, len(iter127))
+                for iter128 in iter127:
+                    oprot.writeI32(iter128)
                 oprot.writeListEnd()
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.stringLengthPercentiles is not None:
             oprot.writeFieldBegin('stringLengthPercentiles', TType.LIST, 8)
             oprot.writeListBegin(TType.LIST, len(self.stringLengthPercentiles))
-            for iter120 in self.stringLengthPercentiles:
-                oprot.writeListBegin(TType.I32, len(iter120))
-                for iter121 in iter120:
-                    oprot.writeI32(iter121)
+            for iter129 in self.stringLengthPercentiles:
+                oprot.writeListBegin(TType.I32, len(iter129))
+                for iter130 in iter129:
+                    oprot.writeI32(iter130)
                 oprot.writeListEnd()
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.timestamps is not None:
             oprot.writeFieldBegin('timestamps', TType.LIST, 200)
             oprot.writeListBegin(TType.I64, len(self.timestamps))
-            for iter122 in self.timestamps:
-                oprot.writeI64(iter122)
+            for iter131 in self.timestamps:
+                oprot.writeI64(iter131)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.key is not None:
@@ -861,90 +1013,90 @@ class TileDriftSeries(object):
             if fid == 1:
                 if ftype == TType.LIST:
                     self.percentileDriftSeries = []
-                    (_etype126, _size123) = iprot.readListBegin()
-                    for _i127 in range(_size123):
-                        _elem128 = iprot.readDouble()
-                        self.percentileDriftSeries.append(_elem128)
+                    (_etype135, _size132) = iprot.readListBegin()
+                    for _i136 in range(_size132):
+                        _elem137 = iprot.readDouble()
+                        self.percentileDriftSeries.append(_elem137)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 2:
                 if ftype == TType.LIST:
                     self.histogramDriftSeries = []
-                    (_etype132, _size129) = iprot.readListBegin()
-                    for _i133 in range(_size129):
-                        _elem134 = iprot.readDouble()
-                        self.histogramDriftSeries.append(_elem134)
+                    (_etype141, _size138) = iprot.readListBegin()
+                    for _i142 in range(_size138):
+                        _elem143 = iprot.readDouble()
+                        self.histogramDriftSeries.append(_elem143)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 3:
                 if ftype == TType.LIST:
                     self.countChangePercentSeries = []
-                    (_etype138, _size135) = iprot.readListBegin()
-                    for _i139 in range(_size135):
-                        _elem140 = iprot.readDouble()
-                        self.countChangePercentSeries.append(_elem140)
+                    (_etype147, _size144) = iprot.readListBegin()
+                    for _i148 in range(_size144):
+                        _elem149 = iprot.readDouble()
+                        self.countChangePercentSeries.append(_elem149)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 4:
                 if ftype == TType.LIST:
                     self.nullRatioChangePercentSeries = []
-                    (_etype144, _size141) = iprot.readListBegin()
-                    for _i145 in range(_size141):
-                        _elem146 = iprot.readDouble()
-                        self.nullRatioChangePercentSeries.append(_elem146)
+                    (_etype153, _size150) = iprot.readListBegin()
+                    for _i154 in range(_size150):
+                        _elem155 = iprot.readDouble()
+                        self.nullRatioChangePercentSeries.append(_elem155)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 5:
                 if ftype == TType.LIST:
                     self.innerCountChangePercentSeries = []
-                    (_etype150, _size147) = iprot.readListBegin()
-                    for _i151 in range(_size147):
-                        _elem152 = iprot.readDouble()
-                        self.innerCountChangePercentSeries.append(_elem152)
+                    (_etype159, _size156) = iprot.readListBegin()
+                    for _i160 in range(_size156):
+                        _elem161 = iprot.readDouble()
+                        self.innerCountChangePercentSeries.append(_elem161)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 6:
                 if ftype == TType.LIST:
                     self.innerNullCountChangePercentSeries = []
-                    (_etype156, _size153) = iprot.readListBegin()
-                    for _i157 in range(_size153):
-                        _elem158 = iprot.readDouble()
-                        self.innerNullCountChangePercentSeries.append(_elem158)
+                    (_etype165, _size162) = iprot.readListBegin()
+                    for _i166 in range(_size162):
+                        _elem167 = iprot.readDouble()
+                        self.innerNullCountChangePercentSeries.append(_elem167)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 7:
                 if ftype == TType.LIST:
                     self.lengthPercentilesDriftSeries = []
-                    (_etype162, _size159) = iprot.readListBegin()
-                    for _i163 in range(_size159):
-                        _elem164 = iprot.readDouble()
-                        self.lengthPercentilesDriftSeries.append(_elem164)
+                    (_etype171, _size168) = iprot.readListBegin()
+                    for _i172 in range(_size168):
+                        _elem173 = iprot.readDouble()
+                        self.lengthPercentilesDriftSeries.append(_elem173)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 8:
                 if ftype == TType.LIST:
                     self.stringLengthPercentilesDriftSeries = []
-                    (_etype168, _size165) = iprot.readListBegin()
-                    for _i169 in range(_size165):
-                        _elem170 = iprot.readDouble()
-                        self.stringLengthPercentilesDriftSeries.append(_elem170)
+                    (_etype177, _size174) = iprot.readListBegin()
+                    for _i178 in range(_size174):
+                        _elem179 = iprot.readDouble()
+                        self.stringLengthPercentilesDriftSeries.append(_elem179)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 200:
                 if ftype == TType.LIST:
                     self.timestamps = []
-                    (_etype174, _size171) = iprot.readListBegin()
-                    for _i175 in range(_size171):
-                        _elem176 = iprot.readI64()
-                        self.timestamps.append(_elem176)
+                    (_etype183, _size180) = iprot.readListBegin()
+                    for _i184 in range(_size180):
+                        _elem185 = iprot.readI64()
+                        self.timestamps.append(_elem185)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
@@ -968,64 +1120,64 @@ class TileDriftSeries(object):
         if self.percentileDriftSeries is not None:
             oprot.writeFieldBegin('percentileDriftSeries', TType.LIST, 1)
             oprot.writeListBegin(TType.DOUBLE, len(self.percentileDriftSeries))
-            for iter177 in self.percentileDriftSeries:
-                oprot.writeDouble(iter177)
+            for iter186 in self.percentileDriftSeries:
+                oprot.writeDouble(iter186)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.histogramDriftSeries is not None:
             oprot.writeFieldBegin('histogramDriftSeries', TType.LIST, 2)
             oprot.writeListBegin(TType.DOUBLE, len(self.histogramDriftSeries))
-            for iter178 in self.histogramDriftSeries:
-                oprot.writeDouble(iter178)
+            for iter187 in self.histogramDriftSeries:
+                oprot.writeDouble(iter187)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.countChangePercentSeries is not None:
             oprot.writeFieldBegin('countChangePercentSeries', TType.LIST, 3)
             oprot.writeListBegin(TType.DOUBLE, len(self.countChangePercentSeries))
-            for iter179 in self.countChangePercentSeries:
-                oprot.writeDouble(iter179)
+            for iter188 in self.countChangePercentSeries:
+                oprot.writeDouble(iter188)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.nullRatioChangePercentSeries is not None:
             oprot.writeFieldBegin('nullRatioChangePercentSeries', TType.LIST, 4)
             oprot.writeListBegin(TType.DOUBLE, len(self.nullRatioChangePercentSeries))
-            for iter180 in self.nullRatioChangePercentSeries:
-                oprot.writeDouble(iter180)
+            for iter189 in self.nullRatioChangePercentSeries:
+                oprot.writeDouble(iter189)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.innerCountChangePercentSeries is not None:
             oprot.writeFieldBegin('innerCountChangePercentSeries', TType.LIST, 5)
             oprot.writeListBegin(TType.DOUBLE, len(self.innerCountChangePercentSeries))
-            for iter181 in self.innerCountChangePercentSeries:
-                oprot.writeDouble(iter181)
+            for iter190 in self.innerCountChangePercentSeries:
+                oprot.writeDouble(iter190)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.innerNullCountChangePercentSeries is not None:
             oprot.writeFieldBegin('innerNullCountChangePercentSeries', TType.LIST, 6)
             oprot.writeListBegin(TType.DOUBLE, len(self.innerNullCountChangePercentSeries))
-            for iter182 in self.innerNullCountChangePercentSeries:
-                oprot.writeDouble(iter182)
+            for iter191 in self.innerNullCountChangePercentSeries:
+                oprot.writeDouble(iter191)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.lengthPercentilesDriftSeries is not None:
             oprot.writeFieldBegin('lengthPercentilesDriftSeries', TType.LIST, 7)
             oprot.writeListBegin(TType.DOUBLE, len(self.lengthPercentilesDriftSeries))
-            for iter183 in self.lengthPercentilesDriftSeries:
-                oprot.writeDouble(iter183)
+            for iter192 in self.lengthPercentilesDriftSeries:
+                oprot.writeDouble(iter192)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.stringLengthPercentilesDriftSeries is not None:
             oprot.writeFieldBegin('stringLengthPercentilesDriftSeries', TType.LIST, 8)
             oprot.writeListBegin(TType.DOUBLE, len(self.stringLengthPercentilesDriftSeries))
-            for iter184 in self.stringLengthPercentilesDriftSeries:
-                oprot.writeDouble(iter184)
+            for iter193 in self.stringLengthPercentilesDriftSeries:
+                oprot.writeDouble(iter193)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.timestamps is not None:
             oprot.writeFieldBegin('timestamps', TType.LIST, 200)
             oprot.writeListBegin(TType.I64, len(self.timestamps))
-            for iter185 in self.timestamps:
-                oprot.writeI64(iter185)
+            for iter194 in self.timestamps:
+                oprot.writeI64(iter194)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.key is not None:
@@ -1084,49 +1236,49 @@ class DriftSpec(object):
             if fid == 1:
                 if ftype == TType.LIST:
                     self.slices = []
-                    (_etype189, _size186) = iprot.readListBegin()
-                    for _i190 in range(_size186):
-                        _elem191 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        self.slices.append(_elem191)
+                    (_etype198, _size195) = iprot.readListBegin()
+                    for _i199 in range(_size195):
+                        _elem200 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        self.slices.append(_elem200)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 2:
                 if ftype == TType.MAP:
                     self.derivations = {}
-                    (_ktype193, _vtype194, _size192) = iprot.readMapBegin()
-                    for _i196 in range(_size192):
-                        _key197 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        _val198 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        self.derivations[_key197] = _val198
+                    (_ktype202, _vtype203, _size201) = iprot.readMapBegin()
+                    for _i205 in range(_size201):
+                        _key206 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        _val207 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        self.derivations[_key206] = _val207
                     iprot.readMapEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 3:
                 if ftype == TType.MAP:
                     self.columnCardinalityHints = {}
-                    (_ktype200, _vtype201, _size199) = iprot.readMapBegin()
-                    for _i203 in range(_size199):
-                        _key204 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
-                        _val205 = iprot.readI32()
-                        self.columnCardinalityHints[_key204] = _val205
+                    (_ktype209, _vtype210, _size208) = iprot.readMapBegin()
+                    for _i212 in range(_size208):
+                        _key213 = iprot.readString().decode('utf-8', errors='replace') if sys.version_info[0] == 2 else iprot.readString()
+                        _val214 = iprot.readI32()
+                        self.columnCardinalityHints[_key213] = _val214
                     iprot.readMapEnd()
                 else:
                     iprot.skip(ftype)
             elif fid == 4:
                 if ftype == TType.STRUCT:
-                    self.tileSize = ai.chronon.api.common.ttypes.Window()
+                    self.tileSize = gen_thrift.common.ttypes.Window()
                     self.tileSize.read(iprot)
                 else:
                     iprot.skip(ftype)
             elif fid == 5:
                 if ftype == TType.LIST:
                     self.lookbackWindows = []
-                    (_etype209, _size206) = iprot.readListBegin()
-                    for _i210 in range(_size206):
-                        _elem211 = ai.chronon.api.common.ttypes.Window()
-                        _elem211.read(iprot)
-                        self.lookbackWindows.append(_elem211)
+                    (_etype218, _size215) = iprot.readListBegin()
+                    for _i219 in range(_size215):
+                        _elem220 = gen_thrift.common.ttypes.Window()
+                        _elem220.read(iprot)
+                        self.lookbackWindows.append(_elem220)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
@@ -1149,24 +1301,24 @@ class DriftSpec(object):
         if self.slices is not None:
             oprot.writeFieldBegin('slices', TType.LIST, 1)
             oprot.writeListBegin(TType.STRING, len(self.slices))
-            for iter212 in self.slices:
-                oprot.writeString(iter212.encode('utf-8') if sys.version_info[0] == 2 else iter212)
+            for iter221 in self.slices:
+                oprot.writeString(iter221.encode('utf-8') if sys.version_info[0] == 2 else iter221)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.derivations is not None:
             oprot.writeFieldBegin('derivations', TType.MAP, 2)
             oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.derivations))
-            for kiter213, viter214 in self.derivations.items():
-                oprot.writeString(kiter213.encode('utf-8') if sys.version_info[0] == 2 else kiter213)
-                oprot.writeString(viter214.encode('utf-8') if sys.version_info[0] == 2 else viter214)
+            for kiter222, viter223 in self.derivations.items():
+                oprot.writeString(kiter222.encode('utf-8') if sys.version_info[0] == 2 else kiter222)
+                oprot.writeString(viter223.encode('utf-8') if sys.version_info[0] == 2 else viter223)
             oprot.writeMapEnd()
             oprot.writeFieldEnd()
         if self.columnCardinalityHints is not None:
             oprot.writeFieldBegin('columnCardinalityHints', TType.MAP, 3)
             oprot.writeMapBegin(TType.STRING, TType.I32, len(self.columnCardinalityHints))
-            for kiter215, viter216 in self.columnCardinalityHints.items():
-                oprot.writeString(kiter215.encode('utf-8') if sys.version_info[0] == 2 else kiter215)
-                oprot.writeI32(viter216)
+            for kiter224, viter225 in self.columnCardinalityHints.items():
+                oprot.writeString(kiter224.encode('utf-8') if sys.version_info[0] == 2 else kiter224)
+                oprot.writeI32(viter225)
             oprot.writeMapEnd()
             oprot.writeFieldEnd()
         if self.tileSize is not None:
@@ -1176,8 +1328,8 @@ class DriftSpec(object):
         if self.lookbackWindows is not None:
             oprot.writeFieldBegin('lookbackWindows', TType.LIST, 5)
             oprot.writeListBegin(TType.STRUCT, len(self.lookbackWindows))
-            for iter217 in self.lookbackWindows:
-                iter217.write(oprot)
+            for iter226 in self.lookbackWindows:
+                iter226.write(oprot)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         if self.driftMetric is not None:
@@ -1346,11 +1498,11 @@ class JoinDriftResponse(object):
             if fid == 1:
                 if ftype == TType.LIST:
                     self.driftSeries = []
-                    (_etype221, _size218) = iprot.readListBegin()
-                    for _i222 in range(_size218):
-                        _elem223 = TileDriftSeries()
-                        _elem223.read(iprot)
-                        self.driftSeries.append(_elem223)
+                    (_etype230, _size227) = iprot.readListBegin()
+                    for _i231 in range(_size227):
+                        _elem232 = TileDriftSeries()
+                        _elem232.read(iprot)
+                        self.driftSeries.append(_elem232)
                     iprot.readListEnd()
                 else:
                     iprot.skip(ftype)
@@ -1368,8 +1520,8 @@ class JoinDriftResponse(object):
         if self.driftSeries is not None:
             oprot.writeFieldBegin('driftSeries', TType.LIST, 1)
             oprot.writeListBegin(TType.STRUCT, len(self.driftSeries))
-            for iter224 in self.driftSeries:
-                iter224.write(oprot)
+            for iter233 in self.driftSeries:
+                iter233.write(oprot)
             oprot.writeListEnd()
             oprot.writeFieldEnd()
         oprot.writeFieldStop()
@@ -1501,8 +1653,8 @@ class JoinSummaryRequest(object):
 
     def __ne__(self, other):
         return not (self == other)
-all_structs.append(TileKey)
-TileKey.thrift_spec = (
+all_structs.append(TileSummaryKey)
+TileSummaryKey.thrift_spec = (
     None,  # 0
     (1, TType.STRING, 'column', 'UTF8', None, ),  # 1
     (2, TType.STRING, 'slice', 'UTF8', None, ),  # 2
@@ -1529,6 +1681,17 @@ TileSeriesKey.thrift_spec = (
     (3, TType.STRING, 'groupName', 'UTF8', None, ),  # 3
     (4, TType.STRING, 'nodeName', 'UTF8', None, ),  # 4
 )
+all_structs.append(NullCounts)
+NullCounts.thrift_spec = (
+    None,  # 0
+    (1, TType.MAP, 'nullCounts', (TType.I32, None, TType.I64, None, False), None, ),  # 1
+    (2, TType.I64, 'rowCount', None, None, ),  # 2
+)
+all_structs.append(TileStats)
+TileStats.thrift_spec = (
+    None,  # 0
+    (1, TType.STRUCT, 'nullCounts', [NullCounts, None], None, ),  # 1
+)
 all_structs.append(TileSummarySeries)
 TileSummarySeries.thrift_spec = (
     None,  # 0
@@ -1831,7 +1994,7 @@ TileSummarySeries.thrift_spec = (
     None,  # 297
     None,  # 298
     None,  # 299
-    (300, TType.STRUCT, 'key', [TileSeriesKey, None], None, ),  # 300
+    (300, TType.STRUCT, 'key', [TileSummaryKey, None], None, ),  # 300
 )
 all_structs.append(TileDrift)
 TileDrift.thrift_spec = (
@@ -2155,8 +2318,8 @@ DriftSpec.thrift_spec = (
     (1, TType.LIST, 'slices', (TType.STRING, 'UTF8', False), None, ),  # 1
     (2, TType.MAP, 'derivations', (TType.STRING, 'UTF8', TType.STRING, 'UTF8', False), None, ),  # 2
     (3, TType.MAP, 'columnCardinalityHints', (TType.STRING, 'UTF8', TType.I32, None, False), None, ),  # 3
-    (4, TType.STRUCT, 'tileSize', [ai.chronon.api.common.ttypes.Window, None], None, ),  # 4
-    (5, TType.LIST, 'lookbackWindows', (TType.STRUCT, [ai.chronon.api.common.ttypes.Window, None], False), None, ),  # 5
+    (4, TType.STRUCT, 'tileSize', [gen_thrift.common.ttypes.Window, None], None, ),  # 4
+    (5, TType.LIST, 'lookbackWindows', (TType.STRUCT, [gen_thrift.common.ttypes.Window, None], False), None, ),  # 5
     (6, TType.I32, 'driftMetric', None,     0, ),  # 6
 )
 all_structs.append(JoinDriftRequest)