quasardb 3.14.2.dev4__cp38-cp38-win_amd64.whl → 3.14.2.dev6__cp38-cp38-win_amd64.whl

quasardb/stats.py

@@ -1,14 +1,20 @@
 import re
+
 import quasardb
 import logging
+from collections import defaultdict
 from datetime import datetime
+from enum import Enum
 
-logger = logging.getLogger('quasardb.stats')
+logger = logging.getLogger("quasardb.stats")
 
+MAX_KEYS = 4 * 1024 * 1024  # 4 million max keys
+stats_prefix = "$qdb.statistics."
 
-stats_prefix = '$qdb.statistics.'
-user_pattern = re.compile(r'\$qdb.statistics.(.*).uid_([0-9]+)$')
-total_pattern = re.compile(r'\$qdb.statistics.(.*)$')
+# Compile these regexes once for speed
+user_pattern = re.compile(r"\$qdb.statistics.(.*).uid_([0-9]+)$")
+total_pattern = re.compile(r"\$qdb.statistics.(.*)$")
+user_clean_pattern = re.compile(r"\.uid_\d+")
 
 
 def is_user_stat(s):
@@ -50,91 +56,36 @@ def of_node(dconn):
     """
 
     start = datetime.now()
-    raw = {
-        k: _get_stat(dconn,k) for k in dconn.prefix_get(stats_prefix, 1000)}
 
-    ret = {'by_uid': _by_uid(raw),
-           'cumulative': _cumulative(raw)}
+    ks = _get_all_keys(dconn)
+    idx = _index_keys(dconn, ks)
+    raw = {k: _get_stat_value(dconn, k) for k in ks}
+
+    ret = {"by_uid": _by_uid(raw, idx), "cumulative": _cumulative(raw, idx)}
 
     check_duration = datetime.now() - start
 
-    ret['cumulative']['check.online'] = 1
-    ret['cumulative']['check.duration_ms'] = int(check_duration.total_seconds() * 1000)
+    ret["cumulative"]["check.online"] = {
+        "value": 1,
+        "type": Type.ACCUMULATOR,
+        "unit": Unit.NONE,
+    }
+    ret["cumulative"]["check.duration_ms"] = {
+        "value": int(check_duration.total_seconds() * 1000),
+        "type": Type.ACCUMULATOR,
+        "unit": Unit.MILLISECONDS,
+    }
 
     return ret
 
-_stat_types = {'node_id': ('constant', None),
-               'operating_system': ('constant', None),
-               'partitions_count': ('constant', 'count'),
-
-               'cpu.system': ('counter', 'ns'),
-               'cpu.user': ('counter', 'ns'),
-               'cpu.idle': ('counter', 'ns'),
-               'startup': ('constant', None),
-               'startup_time': ('constant', None),
-               'shutdown_time': ('constant', None),
-
-               'network.current_users_count': ('gauge', 'count'),
-               'hardware_concurrency': ('gauge', 'count'),
-
-               'check.online': ('gauge', 'count'),
-               'check.duration_ms': ('constant', 'ms'),
-
-               'requests.bytes_in': ('counter', 'bytes'),
-               'requests.bytes_out': ('counter', 'bytes'),
-               'requests.errors_count': ('counter', 'count'),
-               'requests.successes_count': ('counter', 'count'),
-               'requests.total_count': ('counter', 'count'),
-
-               'async_pipelines.merge.bucket_count': ('counter', 'count'),
-               'async_pipelines.merge.duration_us': ('counter', 'us'),
-               'async_pipelines.write.successes_count': ('counter', 'count'),
-               'async_pipelines.write.failures_count': ('counter', 'count'),
-               'async_pipelines.write.time_us': ('counter', 'us'),
-
-               'async_pipelines.merge.max_bucket_count': ('gauge', 'count'),
-               'async_pipelines.merge.max_depth_count': ('gauge', 'count'),
-               'async_pipelines.merge.requests_count': ('counter', 'count'),
-
-               'evicted.count': ('counter', 'count'),
-               'pageins.count': ('counter', 'count'),
-
-               }
-
-async_pipeline_bytes_pattern  = re.compile(r'async_pipelines.pipe_[0-9]+.merge_map.bytes')
-async_pipeline_count_pattern  = re.compile(r'async_pipelines.pipe_[0-9]+.merge_map.count')
-
-def _stat_type(stat_id):
-    if stat_id in _stat_types:
-        return _stat_types[stat_id]
-    elif stat_id.endswith('total_ns'):
-        return ('counter', 'ns')
-    elif stat_id.endswith('total_bytes'):
-        return ('counter', 'bytes')
-    elif stat_id.endswith('read_bytes'):
-        return ('counter', 'bytes')
-    elif stat_id.endswith('written_bytes'):
-        return ('counter', 'bytes')
-    elif stat_id.endswith('total_count'):
-        return ('counter', 'count')
-    elif stat_id.startswith('network.sessions.'):
-        return ('gauge', 'count')
-    elif stat_id.startswith('memory.'):
-        # memory statistics are all gauges i think, describes how much memory currently allocated where
-        return ('gauge', 'bytes')
-    elif stat_id.startswith('persistence.') or stat_id.startswith('disk'):
-        # persistence are also all gauges, describes mostly how much is currently available/used on storage
-        return ('gauge', 'bytes')
-    elif stat_id.startswith('license.'):
-        return ('gauge', None)
-    elif stat_id.startswith('engine_'):
-        return ('constant', None)
-    elif async_pipeline_bytes_pattern.match(stat_id):
-        return ('gauge', 'bytes')
-    elif async_pipeline_count_pattern.match(stat_id):
-        return ('gauge', 'count')
-    else:
-        return None
+
+async_pipeline_bytes_pattern = re.compile(
+    r"async_pipelines.pipe_[0-9]+.merge_map.bytes"
+)
+async_pipeline_count_pattern = re.compile(
+    r"async_pipelines.pipe_[0-9]+.merge_map.count"
+)
+
 
 def stat_type(stat_id):
     """
@@ -146,88 +97,262 @@ def stat_type(stat_id):
 
     This is useful for determining which value should be reported in a dashboard.
     """
-    return _stat_type(stat_id)
+    import warnings
 
+    warnings.warn(
+        "The 'stat_type' method is deprecated and will be removed in a future release."
+        "The stat type and unit are now part of the return value of invocations to the 'of_node' and 'by_node' methods.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
 
-def _calculate_delta_stat(stat_id, prev, cur):
-    logger.info("calculating delta for stat_id = {}, prev = {}. cur = {}".format(stat_id, prev, cur))
+    return None
 
-    stat_type = _stat_type(stat_id)
-    if stat_type == 'counter':
-        return cur - prev
-    elif stat_type == 'gauge':
-        return cur
-    else:
-        return None
 
-def _calculate_delta_stats(prev_stats, cur_stats):
-    ret = {}
-    for stat_id in cur_stats.keys():
-        try:
-            prev_stat = cur_stats[stat_id]
-            cur_stat  = cur_stats[stat_id]
+def _get_all_keys(dconn, n=1024):
+    """
+    Returns all keys from a single node.
 
-            value = _calculate_delta_stat(stat_id, prev_stat, cur_stat)
-            if value is not None:
-                ret[stat_id] = value
+    Parameters:
+    dconn: quasardb.Node
+      Direct node connection to the node we wish to connect to.
 
-        except KeyError:
-            # Stat likely was not present yet in prev_stats
-            pass
+    n: int
+      Number of keys to retrieve.
+    """
+    xs = None
+    increase_rate = 8
+    # keep getting keys while number of results exceeds the given "n"
+    while xs is None or len(xs) >= n:
+        if xs is not None:
+            n = n * increase_rate
+        if n >= MAX_KEYS:
+            raise Exception(f"ERROR: Cannot fetch more than {MAX_KEYS} keys.")
+        xs = dconn.prefix_get(stats_prefix, n)
 
-    return ret
+    return xs
+
+
+class Type(Enum):
+    ACCUMULATOR = 1
+    GAUGE = 2
+    LABEL = 3
+
+
+class Unit(Enum):
+    NONE = 0
+    COUNT = 1
+
+    # Size units
+    BYTES = 32
+
+    # Time/duration units
+    EPOCH = 64
+    NANOSECONDS = 65
+    MICROSECONDS = 66
+    MILLISECONDS = 67
+    SECONDS = 68
 
 
-def calculate_delta(prev, cur):
+_type_string_to_enum = {
+    "accumulator": Type.ACCUMULATOR,
+    "gauge": Type.GAUGE,
+    "label": Type.LABEL,
+}
+
+_unit_string_to_enum = {
+    "none": Unit.NONE,
+    "count": Unit.COUNT,
+    "bytes": Unit.BYTES,
+    "epoch": Unit.EPOCH,
+    "nanoseconds": Unit.NANOSECONDS,
+    "microseconds": Unit.MICROSECONDS,
+    "milliseconds": Unit.MILLISECONDS,
+    "seconds": Unit.SECONDS,
+}
+
+
+def _lookup_enum(dconn, k, m):
+    """
+    Utility function to avoid code duplication: automatically looks up a key's value
+    from QuasarDB and looks it up in provided dict.
+    """
+
+    x = dconn.blob(k).get()
+    x = _clean_blob(x)
+
+    if x not in m:
+        raise Exception(f"Unrecognized unit/type {x} from key {k}")
+
+    return m[x]
+
+
+def _lookup_type(dconn, k):
+    """
+    Looks up and parses/validates the metric type.
+    """
+    assert k.endswith(".type")
+
+    return _lookup_enum(dconn, k, _type_string_to_enum)
+
+
+def _lookup_unit(dconn, k):
     """
-    Calculates the 'delta' between two successive statistic measurements.
+    Looks up and parses/validates the metric type.
     """
-    ret = {}
-    for node_id in cur.keys():
-        ret[node_id] = _calculate_delta_stats(prev[node_id]['cumulative'],
-                                              cur[node_id]['cumulative'])
+    assert k.endswith(".unit")
+
+    return _lookup_enum(dconn, k, _unit_string_to_enum)
+
+
+def _index_keys(dconn, ks):
+    """
+    Takes all statistics keys that are retrieved, and "indexes" them in such a way
+    that we end up with a dict of all statistic keys, their type and their unit.
+    """
+
+    ###
+    # The keys generally look like this, for example:
+    #
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes.uid_1
+    # $qdb.statistics.requests.out_bytes.uid_1.type
+    # $qdb.statistics.requests.out_bytes.uid_1.unit
+    # $qdb.statistics.requests.out_bytes.unit
+    #
+    # For this purpose, we simply get rid of the "uid" part, as the per-uid metrics are guaranteed
+    # to be of the exact same type as all the others. So after trimming those, the keys will look
+    # like this:
+    #
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes.unit
+    # $qdb.statistics.requests.out_bytes.unit
+    #
+    # And after deduplication like this:
+    #
+    # $qdb.statistics.requests.out_bytes
+    # $qdb.statistics.requests.out_bytes.type
+    # $qdb.statistics.requests.out_bytes.unit
+    #
+    # In which case we'll store `requests.out_bytes` as the statistic type, and look up the type
+    # and unit for those metrics and add a placeholder value.
+
+    ret = defaultdict(lambda: {"value": None, "type": None, "unit": None})
+
+    for k in ks:
+        # Remove any 'uid_[0-9]+' part from the string
+        k_ = user_clean_pattern.sub("", k)
+
+        matches = total_pattern.match(k_)
+
+        parts = matches.groups()[0].rsplit(".", 1)
+        metric_id = parts[0]
+
+        if len(parts) > 1 and parts[1] == "type":
+            if ret[metric_id]["type"] == None:
+                # We haven't seen this particular statistic yet
+                ret[metric_id]["type"] = _lookup_type(dconn, k)
+        elif len(parts) > 1 and parts[1] == "unit":
+            if ret[metric_id]["unit"] == None:
+                # We haven't seen this particular statistic yet
+                ret[metric_id]["unit"] = _lookup_unit(dconn, k)
+        else:
+            # It's a value, we look those up later
+            pass
 
     return ret
 
+
 def _clean_blob(x):
-    x_ = x.decode('utf-8', 'replace')
+    """
+    Utility function that decodes a blob as an UTF-8 string, as the direct node C API
+    does not yet support 'string' types and as such all statistics are stored as blobs.
+    """
+    x_ = x.decode("utf-8", "replace")
 
     # remove trailing zero-terminator
-    return ''.join(c for c in x_ if ord(c) != 0)
+    return "".join(c for c in x_ if ord(c) != 0)
 
 
-def _get_stat(dconn, k):
+def _get_stat_value(dconn, k):
     # Ugly, but works: try to retrieve as integer, if not an int, retrieve as
     # blob
+    #
+    # XXX(leon): we could use the index we built to get a much stronger hint
+    #            on what the type is.
     try:
         return dconn.integer(k).get()
+
+    # Older versions of qdb api returned 'alias not found'
     except quasardb.quasardb.AliasNotFoundError:
         return _clean_blob(dconn.blob(k).get())
 
-def _by_uid(stats):
+    # Since ~ 3.14.2, it returns 'Incompatible Type'
+    except quasardb.quasardb.IncompatibleTypeError:
+        return _clean_blob(dconn.blob(k).get())
+
+
+def _by_uid(stats, idx):
     xs = {}
     for k, v in stats.items():
         matches = user_pattern.match(k)
         if is_user_stat(k) and matches:
             (metric, uid_str) = matches.groups()
+
+            if metric.split(".")[-1] in ["type", "unit"]:
+                # We already indexed the type and unit in our idx, this is not interesting
+                continue
+
+            if metric.startswith("serialized"):
+                # Internal stuff we don't care about nor cannot do anything with
+                continue
+
+            if not metric in idx:
+                raise Exception(f"Metric not in internal index: {metric}")
+
+            # Parse user id
             uid = int(uid_str)
+
+            # Prepare our metric dict
+            x = idx[metric].copy()
+            x["value"] = v
+
             if uid not in xs:
                 xs[uid] = {}
 
-            if not metric.startswith('serialized'):
-                xs[uid][metric] = v
+            xs[uid][metric] = x
 
     return xs
 
 
-def _cumulative(stats):
+def _cumulative(stats, idx):
     xs = {}
 
     for k, v in stats.items():
         matches = total_pattern.match(k)
         if is_cumulative_stat(k) and matches:
             metric = matches.groups()[0]
-            if not metric.startswith('serialized'):
-                xs[metric] = v
+
+            if metric.split(".")[-1] in ["type", "unit"]:
+                # We already indexed the type and unit in our idx, this is not interesting
+                continue
+
+            if metric.startswith("serialized"):
+                # Internal stuff we don't care about nor cannot do anything with
+                continue
+
+            if not metric in idx:
+                raise Exception(f"Metric not in internal index: {metric}")
+
+            x = idx[metric].copy()
+            x["value"] = v
+            xs[metric] = x
 
     return xs
+
+
+# async_pipelines.buffer.total_bytes

quasardb/table_cache.py

@@ -1,19 +1,22 @@
 import logging
 
-logger = logging.getLogger('quasardb.table_cache')
+logger = logging.getLogger("quasardb.table_cache")
 
 _cache = {}
 
+
 def clear():
     logger.info("Clearing table cache")
     _cache = {}
 
+
 def exists(table_name: str) -> bool:
     """
     Returns true if table already exists in table cache.
     """
     return table_name in _cache
 
+
 def store(table, table_name=None, force_retrieve_metadata=True):
     """
     Stores a table into the cache. Ensures metadata is retrieved. This is useful if you want
@@ -35,6 +38,7 @@ def store(table, table_name=None, force_retrieve_metadata=True):
 
     return table
 
+
 def lookup(table_name: str, conn, force_retrieve_metadata=True):
     """
     Retrieves table from _cache if already exists. If it does not exist,

{quasardb-3.14.2.dev4.dist-info → quasardb-3.14.2.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quasardb
-Version: 3.14.2.dev4
+Version: 3.14.2.dev6
 Summary: Python API for quasardb
 Home-page: https://www.quasardb.net/
 Author: quasardb SAS

quasardb-3.14.2.dev6.dist-info/RECORD

@@ -0,0 +1,54 @@
+quasardb/INSTALL.vcxproj,sha256=y1omRkLBPJgscguxrvPi5Ei7bVCnbPVeBNgKjka8trc,11046
+quasardb/INSTALL.vcxproj.filters,sha256=TUzMf0eRsFz8Uw2PsrCl3qv23EF01Nq6lQDZic0aIeM,564
+quasardb/__init__.py,sha256=v8N9gkakw2bRY1Ql3P1yBJRjj0HttNkXPPv1S08Nu3I,4751
+quasardb/cmake_install.cmake,sha256=CzbJe8MKo-n_dJdMQj1su_Xl3ZtgLirW9tEmeJJZjYg,1798
+quasardb/firehose.py,sha256=thpTQktgzyY9nTk7vnxckSIZcUATgfkPrBheOLvK1SI,3453
+quasardb/pool.py,sha256=AQfvBwavnNIqPMprqbUua4NuhVxg4FuRVqpa3Aigk9A,8779
+quasardb/qdb_api.dll,sha256=a7k5BIR5aT3KOCyeQAVS7jMHgLS6sKIDd34Y7oJloWQ,25952768
+quasardb/quasardb.cp38-win_amd64.pyd,sha256=la0hw1QdFyB5GsLLxlTEQOs6DmHlEZSzB1LBR9MLhRo,1371136
+quasardb/stats.py,sha256=VLPzV0MwYWD5m06WYlZ2Yy_m1WD1XL8v81P2DPdfpvI,10108
+quasardb/table_cache.py,sha256=9XdHrWb_zpC9gikyZJhFX1qy5rMUc7o7uEPKfyZHjVY,1567
+quasardb/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
+quasardb/CMakeFiles/generate.stamp.depend,sha256=uY8FV-ceJ2Kk-6JfOnsIesDV7jKoUNfkKHNY2Nf7_E8,117
+quasardb/date/ALL_BUILD.vcxproj,sha256=1iBL6p7WOpdP6mTjrTtLA2fTfEUEmYTIkz344kzKGCs,14241
+quasardb/date/ALL_BUILD.vcxproj.filters,sha256=lTQk5MABpmIlZcZqriqmw7SlGUJKSM2xH8HnaKmgC5E,304
+quasardb/date/INSTALL.vcxproj,sha256=pHZvwmmjkMCW-0rfOEsPSaMtLhhJVBAUdBy07d2lbY4,11071
+quasardb/date/INSTALL.vcxproj.filters,sha256=uCTy5RO1Ia8Zn2c4gBdvNuoKVqaPrT-8iV-YFZeQ4vE,564
+quasardb/date/cmake_install.cmake,sha256=yW75iyPm4BHg79vinMFtKKrRn60sdSGSw_6hej0YxH0,3318
+quasardb/date/date.sln,sha256=yzc-WIKaG8yVfp4cIp3UHC2hoVuDgtWU0Vms2xxYSgo,3660
+quasardb/date/dateConfigVersion.cmake,sha256=54LqYG6K3Si4Oq1UDH_bHTMzdr6c3KWFXpO0LdeO0zM,2827
+quasardb/date/dateTargets.cmake,sha256=lRvsUAZZiKJf4UJT06TpLnwIMoKs60Dw2D4l-J9iCoI,2842
+quasardb/date/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
+quasardb/date/CMakeFiles/generate.stamp.depend,sha256=q-iyp1ifyf83pBE1_9faK6GsnBvgEPN49_hRCZFa-IU,650
+quasardb/date/CMakeFiles/Export/df49adab93b9e0c10c64f72458b31971/dateTargets.cmake,sha256=nH0TolGzHCM6ZpwAcktH6LAio29Df7-PbPZJ79AIe0s,4189
+quasardb/extensions/__init__.py,sha256=zvMxXV_zuRSbNrkjsu-qFSEiZahdHmC0lhMqMVRzY_8,120
+quasardb/extensions/writer.py,sha256=DWpm4qqBGtunIPyNuRLtUWouL_Tmr3_Zs3K5c0JtH04,5758
+quasardb/numpy/__init__.py,sha256=gRyPPwMQdVtycC1021oFstlT6xVnA3lhD7AVAZr35Ig,34950
+quasardb/pandas/__init__.py,sha256=w8LXwR4sEXWNnPaSMetltP5kPFBFqTyrUMpQXMK_eX8,16697
+quasardb/pybind11/ALL_BUILD.vcxproj,sha256=mZO3Npg638GMc7WAF0ENrxLvEOz1oeJRt16bToO40mA,20681
+quasardb/pybind11/ALL_BUILD.vcxproj.filters,sha256=WjgQPMVZN7jEaUOdw8Ha03hPfNxybvx_F2wOck10Kqo,308
+quasardb/pybind11/INSTALL.vcxproj,sha256=MzTPsFF2JJscL_nQxTVno81ofCau0R992bwO_A2oM1U,11091
+quasardb/pybind11/INSTALL.vcxproj.filters,sha256=A6FgfSHkVHj8Q5YucG7AXMHuG-K4P3KP5CAcOTx-IpA,564
+quasardb/pybind11/cmake_install.cmake,sha256=5Ez61-TWcg-jLQrLkxHpj-WEWaky_J76HZ7TLaDnFKA,1367
+quasardb/pybind11/pybind11.sln,sha256=jpXRREdn2zRbtWX9ZzTNV5A68nWi_aqDfvz91kb8WMw,3660
+quasardb/pybind11/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
+quasardb/pybind11/CMakeFiles/generate.stamp.depend,sha256=aZoeZTuxueMyoFMODfX1LGlJO2hH-xmNjaTSK9y2gK4,2265
+quasardb/range-v3/ALL_BUILD.vcxproj,sha256=rI5qUFfW98gh26Mm51FR7uPnpTXdIyeAqXoHlHF9qTg,19221
+quasardb/range-v3/ALL_BUILD.vcxproj.filters,sha256=c0k-3qrBreLvjffsj9pJo50YOMqfDYnxLpBqvV1nI00,308
+quasardb/range-v3/INSTALL.vcxproj,sha256=GfWVmqNkDYKypSM2j_3N4mebCHZEih71xnafIFfmt2s,11091
+quasardb/range-v3/INSTALL.vcxproj.filters,sha256=gRtT1h5JgHRtOuUrxO0NpmulUFCF9SuHsU_rh08alHU,564
+quasardb/range-v3/Range-v3.sln,sha256=1KrYjvA6KvVW80E_0yIcnZBz4f2UNGQmj-0DvE88_0g,4506
+quasardb/range-v3/cmake_install.cmake,sha256=AXgperFNmLNR7mzgrdFnRQ1ye0YDjx5Uk4QzTJxNQYM,6952
+quasardb/range-v3/range-v3-config-version.cmake,sha256=57XQ96x5Ec1VvRfoIPND_DSMJ9ZbHUqa8iZEiS0YMvw,3332
+quasardb/range-v3/range-v3-config.cmake,sha256=5zRnJkdQ2k3fYDM1sqSGGwXAXWfc4v39zE2D8Chvfq4,3458
+quasardb/range-v3/range.v3.headers.vcxproj,sha256=frdrcvs9Tg9YBXIabWdOQi6VJXJybYY1uBw3Mq8na1U,58903
+quasardb/range-v3/range.v3.headers.vcxproj.filters,sha256=-9CvkhpzAfIk6_lpiYpbDo_xUktT9HGcwjqsS462kGI,51825
+quasardb/range-v3/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
+quasardb/range-v3/CMakeFiles/generate.stamp.depend,sha256=ABuj3rPyodNYq2D8YDfiaDW-1OssQuMLFStUSvinCxk,1898
+quasardb/range-v3/CMakeFiles/Export/d94ef200eca10a819b5858b33e808f5b/range-v3-targets.cmake,sha256=-NpNuRp4cGl9FnmOmkYljoTJq1r_m9GceVCwIYrDjFM,5393
+quasardb/range-v3/include/range/v3/version.hpp,sha256=jy6iEzXjaavicAw1VSIfvpS7Wu9IoEY51Q5N9m4eaB8,610
+quasardb-3.14.2.dev6.dist-info/LICENSE.md,sha256=0iT1ltzDof6cJr8mSX2PVOGhKjISfCrOYzJg7rG2pOs,1477
+quasardb-3.14.2.dev6.dist-info/METADATA,sha256=oBLvc3OJXwMjdgOWl6sZYCuO-nyy1VyeRuwI9x22u5c,1300
+quasardb-3.14.2.dev6.dist-info/WHEEL,sha256=2M046GvC9RLU1f1TWyM-2sB7cRKLhAC7ucAFK8l8f24,99
+quasardb-3.14.2.dev6.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
+quasardb-3.14.2.dev6.dist-info/RECORD,,

{quasardb-3.14.2.dev4.dist-info → quasardb-3.14.2.dev6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.3.2)
 Root-Is-Purelib: false
 Tag: cp38-cp38-win_amd64
 

quasardb-3.14.2.dev4.dist-info/RECORD

@@ -1,54 +0,0 @@
-quasardb/INSTALL.vcxproj,sha256=3MGjfDVN7LRQWfvvP1APL2AtRtnbUFl1H5RUlJ7fNAs,11046
-quasardb/INSTALL.vcxproj.filters,sha256=TUzMf0eRsFz8Uw2PsrCl3qv23EF01Nq6lQDZic0aIeM,564
-quasardb/__init__.py,sha256=20wagayMPRncEbfEbAu0y8sbMRKj-Lyc_0LB8dMdysM,4670
-quasardb/cmake_install.cmake,sha256=CzbJe8MKo-n_dJdMQj1su_Xl3ZtgLirW9tEmeJJZjYg,1798
-quasardb/firehose.py,sha256=DHYsew-aL1j5PKZonH30CrhXnwHEX1XIAhGbPrzd4PY,3593
-quasardb/pool.py,sha256=lqVZPFejmNHU7EdyeoPkl7yy_-N3BRyuLhNTzIdtg8g,8743
-quasardb/qdb_api.dll,sha256=LxCNvEduafZ1w2oGcjqNnU_mVxZbszq0Fn2_Vn3HgCU,18551808
-quasardb/quasardb.cp38-win_amd64.pyd,sha256=uB7TbgkoxZMtD2fFvy3JVbx5AwwjBLhSZ9-VrOB2HWA,1363456
-quasardb/stats.py,sha256=LDV4F5KTpEXa5sS_syFo_TYn9_W2X1D32Eb43GLutOs,7620
-quasardb/table_cache.py,sha256=t7FFQkms7pFlYDkOhCcLnLS8bWglZjlzX3Qs6gyBG6Q,1559
-quasardb/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
-quasardb/CMakeFiles/generate.stamp.depend,sha256=uY8FV-ceJ2Kk-6JfOnsIesDV7jKoUNfkKHNY2Nf7_E8,117
-quasardb/date/ALL_BUILD.vcxproj,sha256=S3tL5t9rTVLSO1YbyZqMZzzhT4nI2pEGAgIH1N3KE04,14257
-quasardb/date/ALL_BUILD.vcxproj.filters,sha256=lTQk5MABpmIlZcZqriqmw7SlGUJKSM2xH8HnaKmgC5E,304
-quasardb/date/INSTALL.vcxproj,sha256=qRqaayvSWL5OUuya221_vFbF4eaBf-3-HAbH3bzqSq4,11071
-quasardb/date/INSTALL.vcxproj.filters,sha256=uCTy5RO1Ia8Zn2c4gBdvNuoKVqaPrT-8iV-YFZeQ4vE,564
-quasardb/date/cmake_install.cmake,sha256=yW75iyPm4BHg79vinMFtKKrRn60sdSGSw_6hej0YxH0,3318
-quasardb/date/date.sln,sha256=yzc-WIKaG8yVfp4cIp3UHC2hoVuDgtWU0Vms2xxYSgo,3660
-quasardb/date/dateConfigVersion.cmake,sha256=54LqYG6K3Si4Oq1UDH_bHTMzdr6c3KWFXpO0LdeO0zM,2827
-quasardb/date/dateTargets.cmake,sha256=FuGNruC_9fdY0b7YwlC80Kpx9H3Y5CnGXOVNRs6ePRU,2842
-quasardb/date/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
-quasardb/date/CMakeFiles/generate.stamp.depend,sha256=x7HFJ8spOUSAEc-xj5wwyVu1PTGiVafK4i4ijGMbN7k,654
-quasardb/date/CMakeFiles/Export/df49adab93b9e0c10c64f72458b31971/dateTargets.cmake,sha256=kI-gSADoA7MuLXEBcyU3_kYGNyGw6NoQ9chjo7LpEHY,4189
-quasardb/extensions/__init__.py,sha256=zvMxXV_zuRSbNrkjsu-qFSEiZahdHmC0lhMqMVRzY_8,120
-quasardb/extensions/writer.py,sha256=LcGhgr_jrHEDukVukLN1eGKCU0egeZkcCOenFEhZi3A,5928
-quasardb/numpy/__init__.py,sha256=SKBNEXyVQNmiZCtg0rlsnpEwvUYKGhvjshPnyByNCbs,30951
-quasardb/pandas/__init__.py,sha256=LNEmjKvcDD6IdEGrQIgOaBhYH14hH7Y9bF1PFWa6gFg,15331
-quasardb/pybind11/ALL_BUILD.vcxproj,sha256=iLuDHB_e7LuTIjHIt1evFq9EjfWwPZixEwGYoS6MZhs,20737
-quasardb/pybind11/ALL_BUILD.vcxproj.filters,sha256=WjgQPMVZN7jEaUOdw8Ha03hPfNxybvx_F2wOck10Kqo,308
-quasardb/pybind11/INSTALL.vcxproj,sha256=TSmTWt7WaOIgEgThgUTt9LsySHBMqKg74kywGdrzsOM,11091
-quasardb/pybind11/INSTALL.vcxproj.filters,sha256=A6FgfSHkVHj8Q5YucG7AXMHuG-K4P3KP5CAcOTx-IpA,564
-quasardb/pybind11/cmake_install.cmake,sha256=5Ez61-TWcg-jLQrLkxHpj-WEWaky_J76HZ7TLaDnFKA,1367
-quasardb/pybind11/pybind11.sln,sha256=jpXRREdn2zRbtWX9ZzTNV5A68nWi_aqDfvz91kb8WMw,3660
-quasardb/pybind11/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
-quasardb/pybind11/CMakeFiles/generate.stamp.depend,sha256=pvI1o52UhdStD5UHbR3scmC6QqJuIHE0krXJeJOIQE4,2279
-quasardb/range-v3/ALL_BUILD.vcxproj,sha256=VQYlvNXZNXVqJwB1RIcAsTPPLqVLsb7J_TVqMSPFC3A,19265
-quasardb/range-v3/ALL_BUILD.vcxproj.filters,sha256=c0k-3qrBreLvjffsj9pJo50YOMqfDYnxLpBqvV1nI00,308
-quasardb/range-v3/INSTALL.vcxproj,sha256=bJ8yfISiHCDw7zkI3QHDDEViY0DNdZn19kYQqcYgPfw,11091
-quasardb/range-v3/INSTALL.vcxproj.filters,sha256=gRtT1h5JgHRtOuUrxO0NpmulUFCF9SuHsU_rh08alHU,564
-quasardb/range-v3/Range-v3.sln,sha256=1KrYjvA6KvVW80E_0yIcnZBz4f2UNGQmj-0DvE88_0g,4506
-quasardb/range-v3/cmake_install.cmake,sha256=AXgperFNmLNR7mzgrdFnRQ1ye0YDjx5Uk4QzTJxNQYM,6952
-quasardb/range-v3/range-v3-config-version.cmake,sha256=57XQ96x5Ec1VvRfoIPND_DSMJ9ZbHUqa8iZEiS0YMvw,3332
-quasardb/range-v3/range-v3-config.cmake,sha256=E7j1hj2ihfV3jYirDWkQgWZ9vjQTPUI9w2BR-qfV6qM,3458
-quasardb/range-v3/range.v3.headers.vcxproj,sha256=dPGlYOAFujswRP0joZPmye76mQsKkLT2tD0UzXX44a4,58947
-quasardb/range-v3/range.v3.headers.vcxproj.filters,sha256=-9CvkhpzAfIk6_lpiYpbDo_xUktT9HGcwjqsS462kGI,51825
-quasardb/range-v3/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
-quasardb/range-v3/CMakeFiles/generate.stamp.depend,sha256=fRk-WZOhQevkVD_W5AV310RnSvDL-Y83agjjrvHtofI,1909
-quasardb/range-v3/CMakeFiles/Export/d94ef200eca10a819b5858b33e808f5b/range-v3-targets.cmake,sha256=2WN8TJ25ES8AniYWyiS3BFiUz4RAJww7dvvnC-kE7zM,5393
-quasardb/range-v3/include/range/v3/version.hpp,sha256=jy6iEzXjaavicAw1VSIfvpS7Wu9IoEY51Q5N9m4eaB8,610
-quasardb-3.14.2.dev4.dist-info/LICENSE.md,sha256=0iT1ltzDof6cJr8mSX2PVOGhKjISfCrOYzJg7rG2pOs,1477
-quasardb-3.14.2.dev4.dist-info/METADATA,sha256=NjrdXrtH6XFWmyo5hsSpp9qIJsy9YmjiM1OxSZ5Uqco,1300
-quasardb-3.14.2.dev4.dist-info/WHEEL,sha256=rTcqimtzpX3smAWAhGmiRSWAxTY4PqYPNE-p4kscHDQ,99
-quasardb-3.14.2.dev4.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
-quasardb-3.14.2.dev4.dist-info/RECORD,,