ga-api-client 0.3.4__tar.gz → 0.3.5__tar.gz

{ga_api_client-0.3.4/ga_api_client.egg-info → ga_api_client-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ga-api-client
-Version: 0.3.4
+Version: 0.3.5
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

ga_api_client-0.3.5/ga_api/__init__.py

@@ -0,0 +1,8 @@
+from .ga_api_client import System, Tenant, Repository, pprint
+from .hyper_log_log import HyperLogLog
+from .rate import Rate
+from .capture import CaptureMin, CaptureMax, CaptureAnyMin, CaptureAnyMax
+from .std import Std
+from .average import Average
+from .tdigest import TDigest
+from .field_tree import FieldTable, field_table

ga_api_client-0.3.5/ga_api/average.py

@@ -0,0 +1,38 @@
+import math
+
+class Average:
+    def __init__(self, arg=[0, 0]):
+        self._sum = arg[0]
+        self._count = arg[1]
+    def __add__(self, other):
+        return Average([self._sum + other._sum, self._count + other._count])
+        # return HyperLogLog(bytearray(max(a,b) for a, b in zip(self._rmem, other._rmem)))
+
+    def __radd__(self, other):
+        return Average([self._sum + other._sum, self._count + other._count])
+        # return HyperLogLog(bytearray(max(a,b) for a, b in zip(self._rmem, other._rmem)))
+
+    def __iadd__(self, other):
+        self._sum += other._sum
+        self._count += other._count
+        return self
+
+    def __str__(self):
+        return f'{self.value()}'
+
+    def __repr__(self):
+        return f'$avg(sum={self._sum}, count={self._count})'
+
+    def value(self):
+        if self._count == 0:
+            return math.nan
+        return self._sum / self._count
+
+if __name__ == '__main__':
+    x = Average([10, 2])
+    y = Average([10, 5])
+    print('x = ', x)
+    print('y = ', y)
+    print('x + y = ', x + y)
+    print('repr(x) = ', repr(x))
+    print('repr(y) = ', repr(y))

ga_api_client-0.3.5/ga_api/capture.py

@@ -0,0 +1,144 @@
+from datetime import datetime, timezone
+class CaptureBase:
+    def __init__(self, value=None, time=None):
+        # 如果 value 是列表，則分配 _v 和 _t
+        if isinstance(value, list):
+            time = value[0]
+            self._v = value[1]
+        else:
+            self._v = value
+
+        # convert _v to datetime object
+        self._v = self._parse_datetime(self._v)
+
+        # convert _t to datetime object
+        self._t = self._parse_datetime(time)
+        
+        if self._t is None:
+            self._t = datetime.fromtimestamp(0, tz=timezone.utc)
+
+
+    def _parse_datetime(self, date_str):
+        if isinstance(date_str, str) and date_str.startswith('d:'):
+            try:
+                return datetime.fromisoformat(date_str[2:])
+            except ValueError as e:
+                raise ValueError(f"Invalid datetime format: {date_str}") from e
+        return date_str
+
+    def compare(self, other):
+        raise NotImplementedError("Subclasses must implement `compare` method.")
+
+    def __add__(self, other):
+        if self._t is None:
+            return self.__class__([other._v, other._t])
+        if other._t is None:
+            return self.__class__([self._v, self._t])
+        return self.compare(other)
+
+    def __radd__(self, other):
+        return self + other
+
+    def __iadd__(self, other):
+        if self._t is None:
+            self._v = other._v
+            self._t = other._t
+        elif other._t is not None:
+            result = self.compare(other)
+            self._v = result._v
+            self._t = result._t
+        return self
+
+    def __str__(self):
+        return f'{self._v}'
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}(v={repr(self._v)}, t={repr(self._t)})'
+
+
+class CaptureAnyMin(CaptureBase):
+    def compare(self, other):
+        print(repr(self), repr(other))
+        if self._t is None:
+            return self.__class__([other._t, other._v])
+        elif other._t is None:
+            return self.__class__([self._t, self._v])
+        elif self._t < other._t:
+            return self.__class__([self._t, self._v])
+        return self.__class__([other._t, other._v])
+
+
+class CaptureAnyMax(CaptureBase):
+    def compare(self, other):
+        print(repr(self), repr(other))
+        if self._t is None:
+            return self.__class__([other._t, other._v])
+        elif other._t is None:
+            return self.__class__([self._t, self._v])
+        elif self._t > other._t:
+            return self.__class__([self._t, self._v])
+        return self.__class__([other._t, other._v])
+
+
+class CaptureMin(CaptureBase):
+    def compare(self, other):
+        if self._v is None:
+            return self.__class__([other._t, other._v ])
+        elif other._v is None:
+            return self.__class__([self._t, self._v])
+        return self.__class__([self._t, min(self._v, other._v)])
+
+
+class CaptureMax(CaptureBase):
+    def compare(self, other):
+        if self._v is None:
+            return self.__class__([other._t, other._v ])
+        elif other._v is None:
+            return self.__class__([self._t, self._v])
+        return self.__class__([self._t, max(self._v, other._v)])
+
+if __name__ == '__main__':
+    # Test CaptureAnyMin
+    print('CaptureAnyMin')
+    a = CaptureAnyMin([5, 'd:2024-12-01T00:00:00'])
+    b = CaptureAnyMin([10, 'd:2024-12-02T00:00:00'])
+
+    print(a + b)  # CaptureAnyMin(v=5, t=datetime.datetime(2024, 12, 1, 0, 0))
+
+    a += b
+    print(a)  # CaptureAnyMin(v=5, t=datetime.datetime(2024, 12, 1, 0, 0))
+    print('CaptureAnyMax')
+    # Test CaptureAnyMax
+    c = CaptureAnyMax([5, 'd:2024-12-01T00:00:00'])
+    d = CaptureAnyMax([10, 'd:2024-12-02T00:00:00'])
+
+    print(c + d)  # CaptureAnyMax(v=10, t=datetime.datetime(2024, 12, 2, 0, 0))
+
+    c += d
+    print(c)  # CaptureAnyMax(v=10, t=datetime.datetime(2024, 12, 2, 0, 0))
+    print('CaptureMin')
+    # Test CaptureMin
+    e = CaptureMin(10)
+    f = CaptureMin(5)
+    print(e + f)  # CaptureMin(v=5, t=None)
+    e += f
+    print(e)  # CaptureMin(v=5, t=None)
+    
+    e = CaptureMin('d:2024-12-01T00:00:00')
+    f = CaptureMin('d:2024-12-02T00:00:00')
+    print(e + f)  # CaptureMin(v=5, t=None)
+    e += f
+    print(e)  # CaptureMin(v=5, t=None)
+    
+    
+    e = CaptureMax(5)
+    f = CaptureMax(10)
+    print(e + f)  # CaptureMin(v=5, t=None)
+    e += f
+    print(e)  # CaptureMin(v=5, t=None)
+    
+    e = CaptureMax('d:2024-12-01T00:00:00')
+    f = CaptureMax('d:2024-12-02T00:00:00')
+    print(e + f)  # CaptureMin(v=5, t=None)
+    e += f
+    print(e)  # CaptureMin(v=5, t=None)

{ga_api_client-0.3.4 → ga_api_client-0.3.5}/ga_api/ga_api_client.py

@@ -13,6 +13,12 @@ from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes # 3
 import aiohttp # 3.8.1
 import pandas as pd # 1.4.2
 from .hyper_log_log import HyperLogLog
+from .average import Average
+from .tdigest import TDigest
+from .rate import Rate
+from .std import Std
+from .capture import CaptureMin, CaptureMax, CaptureAnyMin, CaptureAnyMax
+
 
 def _logtime(ts):
     return time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(ts))
@@ -532,9 +538,24 @@ class Tenant(Client):
         logging.info(f'status={status} dsid={dsid} plid={plid} ts={_logtime(ts)}')
         return rlt if isinstance(rlt, list) else []
 
+MOPER_MAP = {
+    "$distinct": HyperLogLog,
+    "$count": float,
+    "$sum": float,
+    "$capMin": CaptureMin,
+    "$capMax": CaptureMax,
+    "$capAnyMin": CaptureAnyMin,
+    "$capAnyMax": CaptureAnyMax,
+    "$std": Std,
+    "$avg": Average,
+    "$tDigest": TDigest,
+    "$rate": Rate,
+}
+
 def _compute_kcol_mcol(pipeline):
     kcol = 0 # key columns
     mcol = 0 # mtr columns
+    moper = []
     if 'bucket' in pipeline:
         for bkt in pipeline['bucket']:
             if bkt[0] in ['$distinctTuple','enumTuple']:
@@ -546,10 +567,25 @@ def _compute_kcol_mcol(pipeline):
     if 'metric' in pipeline:
         # each metric introduce two columns
         mcol += len(pipeline['metric']) * 2
-    return kcol, mcol
+        for m in pipeline['metric']:
+            if m[0] in MOPER_MAP:
+                moper.append(m[0])
+            elif m[0] in ['$capNum', '$capDate']:
+                if not 'method' in m[1] or m[1]['method'] == '%max':
+                    moper.append('$capMax')
+                else:
+                    moper.append('$capMin')
+            elif m[0] == '$capAny':
+                if not 'method' in m[1] or m[1]['method'] == '%max':
+                    moper.append('$capAnyMax')
+                else:
+                    moper.append('$capAnyMin')
+            else:  
+                raise Exception(f"unknown metric operation {m[0]}")
+    return kcol, mcol, moper
 
 class _translate_table:
-    def __init__(self, table, ts, kcol, mcol):
+    def __init__(self, table, ts, kcol, mcol, moper):
         if isinstance(table, list) and len(table) > 0:
             self.table = table
         else:
@@ -557,29 +593,34 @@ class _translate_table:
             mtr_cols = list(itertools.repeat(math.nan, mcol))
             self.table = [key_cols+mtr_cols]
         self.ts = ts
+        self.kcol = kcol
+        self.moper = moper
 
     def __iter__(self):
         for input_row in self.table:
             output_row = [] if self.ts is None else [self.ts]
-            for elem in input_row:
-                if type(elem) == list:
-                    output_row.append(tuple(elem))
-                elif type(elem) == str and elem.startswith('h:'):
-                    output_row.append(HyperLogLog(elem))
+            for idx, elem in enumerate(input_row):
+                if idx < self.kcol:
+                    if type(elem) == list:
+                        output_row.append(tuple(elem))
+                    else:
+                        output_row.append(elem)
                 else:
-                    output_row.append(elem)
+                    moper_idx = self.moper[int((idx-self.kcol)/2)]
+                    output_row.append(MOPER_MAP[moper_idx](elem))
             yield output_row
 
 class _translate_rlts:
-    def __init__(self, tsidx, rlts, kcol, mcol):
+    def __init__(self, tsidx, rlts, kcol, mcol, moper):
         self.tsidx = tsidx
         self.rlts = rlts
         self.kcol = kcol
         self.mcol = mcol
+        self.moper = moper
 
     def __iter__(self):
         for ts, rlt in zip(self.tsidx, self.rlts):
-            yield _translate_table(rlt, ts, self.kcol, self.mcol)
+            yield _translate_table(rlt, ts, self.kcol, self.mcol, self.moper)
 
 TZINFO = datetime.datetime.now().astimezone().tzinfo
 def _get_utc_timestamp(ts):
@@ -615,8 +656,8 @@ class Adhoc:
         start = pd.Timestamp(ts).floor(freq_str)
         end = start + delta
         table = await self._tenant.execute_adhoc(self.pid, _get_utc_timestamp(start), _get_utc_timestamp(end), series)
-        kcol, mcol = _compute_kcol_mcol(self.pipeline)
-        return pd.DataFrame(_translate_table(table, None, kcol, mcol), columns=columns)
+        kcol, mcol, moper = _compute_kcol_mcol(self.pipeline)
+        return pd.DataFrame(_translate_table(table, None, kcol, mcol, moper), columns=columns)
 
     async def _read_range(self, dts, series, columns=None, refresh=True):
         if refresh:
@@ -639,8 +680,8 @@ class Adhoc:
             for task in tasks:
                 task.cancel()
             raise e
-        kcol, mcol = _compute_kcol_mcol(self.pipeline)
-        iter = itertools.chain.from_iterable(_translate_rlts(tsidx, rlts, kcol, mcol))
+        kcol, mcol, moper = _compute_kcol_mcol(self.pipeline)
+        iter = itertools.chain.from_iterable(_translate_rlts(tsidx, rlts, kcol, mcol, moper))
         return pd.DataFrame(iter, columns=columns)
 
     async def read_data(self, dts, *args, **kwargs):
@@ -683,8 +724,8 @@ class Pipeline:
         freq_str = f"{self._dset.conf['freq']}s"
         start = ts.floor(freq_str)
         table = await self._tenant.query_pipeline_data(self._dset.dsid, self.plid, _get_utc_timestamp(start))
-        kcol, mcol = _compute_kcol_mcol(self.conf['pipeline'])
-        return pd.DataFrame(_translate_table(table, None, kcol, mcol), columns=columns)
+        kcol, mcol, moper = _compute_kcol_mcol(self.conf['pipeline'])
+        return pd.DataFrame(_translate_table(table, None, kcol, mcol, moper), columns=columns)
 
     async def _read_range(self, dts, columns=None):
         tasks = []
@@ -703,8 +744,8 @@ class Pipeline:
             for task in tasks:
                 task.cancel()
             raise e
-        kcol, mcol = _compute_kcol_mcol(self.conf['pipeline'])
-        iter = itertools.chain.from_iterable(_translate_rlts(tsidx, rlts, kcol, mcol))
+        kcol, mcol, moper = _compute_kcol_mcol(self.conf['pipeline'])
+        iter = itertools.chain.from_iterable(_translate_rlts(tsidx, rlts, kcol, mcol, moper))
         return pd.DataFrame(iter, columns=columns)
 
     async def read_data(self, dts, *args, **kwargs):

ga_api_client-0.3.5/ga_api/rate.py

@@ -0,0 +1,50 @@
+import math
+from datetime import datetime, timezone
+class Rate:
+    def __init__(self, arg=[0, math.inf, 0]):
+        self._sum = arg[0]
+        self._start_ms = arg[1]
+        self._end_ms = arg[2]
+        if (isinstance(self._start_ms, str) and self._start_ms.startswith('d:')):
+            self._start_ms = datetime.fromisoformat(self._start_ms[2:]).timestamp() * 1000
+        if (isinstance(self._end_ms, str) and self._end_ms.startswith('d:')):
+            self._end_ms = datetime.fromisoformat(self._end_ms[2:]).timestamp() * 1000
+            
+    def __add__(self, other):
+        first = self._start_ms if self._start_ms < other._start_ms else other._start_ms
+        last = self._end_ms if self._end_ms > other._end_ms else other._end_ms
+        return Rate([self._sum + other._sum, first, last])
+
+    def __radd__(self, other):
+        first = self._start_ms if self._start_ms < other._start_ms else other._start_ms
+        last = self._end_ms if self._end_ms > other._end_ms else other._end_ms
+        return Rate([self._sum + other._sum, first, last])
+
+    def __iadd__(self, other):
+        self._sum += other._sum
+        self._start_ms = self._start_ms if self._start_ms < other._start_ms else other._start_ms
+        self._end_ms = self._end_ms if self._end_ms > other._end_ms else other._end_ms        
+        return self
+
+    def __str__(self):
+        return f'{self.value()}'
+
+    def __repr__(self):
+        if self._end_ms <= self._start_ms:
+            return f'$rate (empty)'
+        return f'$rate(sum={self._sum}, start={datetime.fromtimestamp(self._start_ms/1000, tz=timezone.utc)}, end={datetime.fromtimestamp(self._end_ms/1000, tz=timezone.utc)}'
+    def value(self):
+        if self._end_ms <= self._start_ms:
+            return math.nan
+        return self._sum / ((self._end_ms - self._start_ms)/1000)
+
+if __name__ == '__main__':
+    x = Rate([10, 1734592909000, 1734592910000])
+    y = Rate([20, 1734592909000, 1734592910000])
+    z = Rate([30, "d:2020-12-20T10:00:00Z", "d:2020-12-20T10:00:05Z"])
+    print('x = ', x)
+    print('y = ', y)
+    print('x + y = ', x + y)
+    print('repr(x) = ', repr(x))
+    print('repr(y) = ', repr(y))
+    print('z = ', z)

ga_api_client-0.3.5/ga_api/std.py

@@ -0,0 +1,47 @@
+import math
+class Std:
+    def __init__(self, arg=[0, 0, 0]):
+        self._mean = arg[0]
+        self._count = arg[1]
+        self._variance = arg[2]
+    def __add__(self, other):
+        new_count = self._count + other._count
+        new_mean = (self._mean * self._count + other._mean * other._count) / new_count
+        new_variance = self._variance + other._variance + (self._mean - other._mean)**2 * self._count * other._count / new_count
+        return Std([new_mean, new_count, new_variance])
+
+    def __radd__(self, other):
+        new_count = self._count + other._count
+        new_mean = (self._mean * self._count + other._mean * other._count) / new_count
+        new_variance = self._variance + other._variance + (self._mean - other._mean)**2 * self._count * other._count / new_count
+        return Std([new_mean, new_count, new_variance])
+
+    def __iadd__(self, other):
+        new_count = self._count + other._count
+        new_mean = (self._mean * self._count + other._mean * other._count) / new_count
+        new_variance = self._variance + other._variance + (self._mean - other._mean)**2 * self._count * other._count / new_count
+        self._mean = new_mean
+        self._count = new_count
+        self._variance = new_variance
+        return self
+
+    def __str__(self):
+        return f'{self.value()}'
+
+    def __repr__(self):
+        return f'$std(mean={self._mean}, count={self._count}, variance={self._variance})'
+
+    def value(self):
+        if self._count == 0:
+            return math.nan
+        return math.sqrt(self._variance / self._count)
+
+if __name__ == '__main__':
+    pass
+    # x = Std([10, 1734592909000, 1734592910000])
+    # y = Std([20, 1734592909000, 1734592910000])
+    # print('x = ', x)
+    # print('y = ', y)
+    # print('x + y = ', x + y)
+    # print('repr(x) = ', repr(x))
+    # print('repr(y) = ', repr(y))

ga_api_client-0.3.5/ga_api/tdigest.py

@@ -0,0 +1,189 @@
+import math
+# To use in pandas df['PR90'] = df['tDigest'].apply(lambda x: x.quantile(0.9))
+# print tDigest would output the median
+# Supported Method: min, max, mean, sum, empty, quantile
+
+class Centroid:
+    def __init__(self, mean, weight):
+        self.mean = mean
+        self.weight = weight
+
+    def update(self, sum_, weight):
+        sum_ += self.mean * self.weight
+        self.weight += weight
+        self.mean = sum_ / self.weight
+        return sum_
+
+class TDigest:
+    def __init__(self, arg=[[math.inf, 0, 64]]):
+        centroids = arg[1:]
+        self.centroids = []
+        self.min = arg[0][0]
+        self.max = arg[0][1]
+        self.count = 0
+        self.sum = 0
+        self.max_size = arg[0][2]
+
+        for c in centroids:
+            # Assume each centroid is a tuple (mean, weight)
+            self.sum += c[0] * c[1]
+            self.count += c[1]
+            self.centroids.append(Centroid(c[0], c[1]))
+    
+    def __add__(self, other):
+        new_one = TDigest([[math.inf, 0, max(self.max_size, other.max_size)]])
+        new_one.update(self)
+        new_one.update(other)
+        return new_one
+    
+    def __radd__(self, other):
+        new_one = TDigest([[math.inf, 0, max(self.max_size, other.max_size)]])
+        new_one.update(self)
+        new_one.update(other)
+        return new_one
+    
+    def __iadd__(self, other):
+        self.update(other)
+        return self
+    
+    def __str__(self):
+        return f'{self.quantile(0.5)}'
+    
+    def __repr__(self):
+        return f'$tDigest({self.output()})'
+    
+    def output(self):
+        centroids = [[c.mean, c.weight] for c in self.centroids]
+        centroids.insert(0, [self.min, self.max, self.max_size])
+        return centroids
+
+    def __k_to_q(self, k, d):
+        k_div_d = k / d
+        if k_div_d >= 0.5:
+            base = 1 - k_div_d
+            return 1 - 2 * base * base
+        else:
+            return 2 * k_div_d * k_div_d
+
+    def update(self, another):
+        if not isinstance(another, TDigest):
+            return
+
+        new_centroids = []
+        self.centroids.extend(another.centroids)
+        self.centroids.sort(key=lambda c: c.mean)
+        self.min = min(self.min, another.min)
+        self.max = max(self.max, another.max)
+        self.count += another.count
+
+        new_sum = 0
+        k_limit = 1
+        q_limit_times_count = self.__k_to_q(k_limit, self.max_size) * self.count
+        k_limit += 1
+
+        centroid_idx = 0
+        cur_centroid = self.centroids[centroid_idx]
+        centroid_idx += 1
+
+        weight_so_far = cur_centroid.weight
+        sums_to_merge = 0
+        weight_to_merge = 0
+
+        for _ in range(1, len(self.centroids)):
+            next_centroid = self.centroids[centroid_idx]
+            centroid_idx += 1
+
+            next_sum = next_centroid.mean * next_centroid.weight
+            weight_so_far += next_centroid.weight
+
+            if weight_so_far <= q_limit_times_count:
+                sums_to_merge += next_sum
+                weight_to_merge += next_centroid.weight
+            else:
+                new_sum += cur_centroid.update(sums_to_merge, weight_to_merge)
+                sums_to_merge = 0
+                weight_to_merge = 0
+                new_centroids.append(cur_centroid)
+
+                q_limit_times_count = self.__k_to_q(k_limit, self.max_size) * self.count
+                k_limit += 1
+                cur_centroid = next_centroid
+
+        new_sum += cur_centroid.update(sums_to_merge, weight_to_merge)
+        new_centroids.append(cur_centroid)
+
+        self.centroids = new_centroids
+        self.sum = new_sum
+
+    def quantile(self, q):
+        if q <= 0:
+            return self.min
+        elif q >= 1:
+            return self.max
+        elif self.count == 0:
+            return math.nan
+
+        rank = q * self.count
+        pos = None
+        weight_so_far = None
+
+        if q > 0.5:
+            pos = 0
+            weight_so_far = self.count
+            for i in range(len(self.centroids) - 1, -1, -1):
+                weight_so_far -= self.centroids[i].weight
+                if rank >= weight_so_far:
+                    pos = i
+                    break
+        else:
+            pos = len(self.centroids) - 1
+            weight_so_far = 0
+            for i, centroid in enumerate(self.centroids):
+                if rank < weight_so_far + centroid.weight:
+                    pos = i
+                    break
+                weight_so_far += centroid.weight
+
+        delta = 0
+        min_ = self.min
+        max_ = self.max
+
+        if len(self.centroids) > 1:
+            if pos == 0:
+                delta = self.centroids[pos + 1].mean - self.centroids[pos].mean
+                max_ = self.centroids[pos + 1].mean
+            elif pos == len(self.centroids) - 1:
+                delta = self.centroids[pos].mean - self.centroids[pos - 1].mean
+                min_ = self.centroids[pos - 1].mean
+            else:
+                delta = (self.centroids[pos + 1].mean - self.centroids[pos - 1].mean) / 2
+                min_ = self.centroids[pos - 1].mean
+                max_ = self.centroids[pos + 1].mean
+
+        value = (self.centroids[pos].mean +
+                 ((rank - weight_so_far) / self.centroids[pos].weight - 0.5) * delta)
+
+        if value < min_:
+            value = min_
+        elif value > max_:
+            value = max_
+
+        return value
+
+    def mean(self):
+        return self.sum / self.count if self.count > 0 else math.nan
+
+    def sum(self):
+        return self.sum
+
+    def min(self):
+        return self.min
+
+    def max(self):
+        return self.max
+
+    def empty(self):
+        return self.count == 0
+
+    def max_size(self):
+        return self.max_size

{ga_api_client-0.3.4 → ga_api_client-0.3.5/ga_api_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ga-api-client
-Version: 0.3.4
+Version: 0.3.5
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{ga_api_client-0.3.4 → ga_api_client-0.3.5}/ga_api_client.egg-info/SOURCES.txt

@@ -4,9 +4,14 @@ pyproject.toml
 setup.cfg
 setup.py
 ga_api/__init__.py
+ga_api/average.py
+ga_api/capture.py
 ga_api/field_tree.py
 ga_api/ga_api_client.py
 ga_api/hyper_log_log.py
+ga_api/rate.py
+ga_api/std.py
+ga_api/tdigest.py
 ga_api_client.egg-info/PKG-INFO
 ga_api_client.egg-info/SOURCES.txt
 ga_api_client.egg-info/dependency_links.txt

{ga_api_client-0.3.4 → ga_api_client-0.3.5}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = ga-api-client
-version = 0.3.4
+version = 0.3.5
 long_description = file: README.md
 long_description_content_type = text/markdown
 classifiers = 

ga_api_client-0.3.4/ga_api/__init__.py

@@ -1,3 +0,0 @@
-from .ga_api_client import System, Tenant, Repository, pprint
-from .hyper_log_log import HyperLogLog
-from .field_tree import FieldTable, field_table