deltacat 0.1.8__py3-none-any.whl → 0.1.11__py3-none-any.whl

deltacat/autoscaler/node_group.py

@@ -1,230 +0,0 @@
-import ray
-import re
-import time
-import yaml
-import logging
-from typing import Optional, Union, List, Dict, Any, Callable, Tuple
-from ray.util.placement_group import (
-	placement_group,
-	placement_group_table,
-	remove_placement_group,
-	get_current_placement_group
-)
-
-from ray.util.scheduling_strategies import PlacementGroupSchedulingStrategy
-from ray.experimental.state.api import list_placement_groups, get_node, get_placement_group
-
-
-from deltacat import logs
-logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
-
-class NodeGroupManager():
-
-	def __init__(self,path: str, gname: str):
-		"""Node Group Manager
-		Args:
-			path: cluster yaml file
-			gname: node group prefix, e.g., 'partition'
-		"""
-		#cluster init status:
-		self.NODE_GROUP_PREFIX=gname
-		self.cluster_config=self._read_yaml(path)
-		self.init_groups = self._cluster_node_groups(self.cluster_config)
-		self.init_group_res = self._parse_node_resources()
-		
-	def _cluster_node_groups(self, config: Dict[str, Any]) -> Dict[str, Any]:
-		"""Get Worker Groups
-		Args:
-			config: cluster yaml data
-		Returns: 
-			worker groups: a dict of worker node group
-
-		"""
-		avail_node_types =  list(config['available_node_types'].items())
-		#exclude head node type
-		head_node_types = [nt for nt in avail_node_types if 'resources' in nt[1] and 'CPU' in nt[1]['resources'] and nt[1]['resources']['CPU']==0][0]
-		worker_node_types = [x for x in avail_node_types if x !=head_node_types]
-		#assuming homogenous cluster
-		#in future, update with fleet resource
-		if len(worker_node_types)>0:
-			self.INSTANCE_TYPE = worker_node_types[0][1]['node_config']['InstanceType']
-		return worker_node_types
-
-
-	def _read_yaml(self, path: str) -> Dict[str, Any]:
-		with open(path, "rt") as f:
-			return yaml.safe_load(f)
-
-	def _update_groups(self) -> List[Tuple[str, float]]:
-		"""
-			Node groups can come and go during runtime, whenever a node group is needed, we need to check the current available groups
-		Returns:
-			current_groups: dict of custom resource groups
-		"""
-		#Add 1.1 second latency to avoid inconsistency issue between raylet and head
-		time.sleep(1.1)
-		all_available_res = ray.available_resources()
-		current_groups =[(k,all_available_res[k]) for k in all_available_res.keys() if self.NODE_GROUP_PREFIX in k]
-		return current_groups
-
-	def _parse_node_resources(self) -> Dict[str, Dict[str, float]]:
-		"""
-			Parse resources per node to get detailed resource tighted to each node group
-			Returns:
-				group_res: a dict of resources, e.g., {'CPU':0,'memory':0,'object_store_memory':0}
-		"""
-		all_available_resources= ray._private.state.state._available_resources_per_node()
-		group_keys = [x[0] for x in self.init_groups]
-		group_res={}
-		for k in group_keys:
-			group_res[k]={'CPU':0,'memory':0,'object_store_memory':0,'node_id':[]}
-		for v in all_available_resources.values():
-			keys =v.keys()
-			r = re.compile(self.NODE_GROUP_PREFIX)
-			partition=list(filter(r.match, list(keys)))
-			r = re.compile("node:")
-			node_id = list(filter(r.match, list(keys)))
-			if len(partition)>0:
-				partition = partition[0]
-			if len(node_id)>0:
-				node_id = node_id[0]
-			if self.NODE_GROUP_PREFIX in partition:
-				group_res[partition]['CPU']+=v['CPU']
-				group_res[partition]['memory']+=v['memory']
-				group_res[partition]['object_store_memory']+=v['object_store_memory']
-				group_res[partition]['node_id'].append(node_id)
-		return group_res
-
-	def _update_group_res(self, gname: str) -> Dict[str, Union[str, float]]:
-		"""
-			Get the realtime resource of a node group
-			Args:
-				gname: name of node group
-			Returns:
-				group_res: dict of updated resource(cpu, memory, object store memory) for a given group
-		"""
-		all_available_resources= ray._private.state.state._available_resources_per_node()
-		group_res={'CPU':0,'memory':0,'object_store_memory':0,'node_id':[]}
-		for v in all_available_resources.values():
-			keys =v.keys()
-			r = re.compile("node:")
-			node_id = list(filter(r.match, list(keys)))
-			if len(node_id)>0:
-				node_id = node_id[0]
-			if gname in v.keys():
-				group_res['CPU']+=v['CPU']
-				group_res['memory']+=v['memory']
-				group_res['object_store_memory']+=v['object_store_memory']
-				group_res['node_id'].append(node_id)
-		return group_res
-
-	def get_one_group(self) -> Optional[Dict[str, Union[str, float]]]:
-		"""
-			Pop up one node group 
-			Returns:
-				group_res: dict of node group resource, {"group":"partition_1","CPU":2,...}
-		"""
-		current_groups = self._update_groups()
-		if len(current_groups)>0:
-			gname = current_groups[-1][0]
-			group_res=self._update_group_res(gname)
-			group_res['group']=gname
-			try:
-				group_res['group_res']=ray.available_resources()[gname]
-			except Exception as e:
-				print("There is no available resources for %s"%gname)
-				return None
-			return group_res
-		else:
-			return None
-
-	def get_group_by_name(self, gname: str) -> Optional[Dict[str, Union[str, float]]]:
-		"""
-			Get the specific node group given its pre-filled name
-			Args: 
-				gname: name of the node group
-			Returns:
-				group_res: dict of node group resource
-
-		"""
-		group_res=self._update_group_res(gname)
-		group_res['group']=gname		
-		try:
-			group_res['group_res']=ray.available_resources()[gname]
-		except Exception as e:
-			print("There is no available resources for %s"%gname)
-			return None
-		return group_res
-
-
-class PlacementGroupManager():
-	"""Placement Group Manager
-	Create a list of placement group with the desired number of cpus
-	e.g., create a pg with 32 cpus, then this class will look for a node that has 32 cpus, and collect all 
-	resources, including cpu, memory, and object store;
-	How to use:
-		```
-			from deltacat.autoscaler.node_group import PlacementGroupManager as pgm
-			pgm = pgm(10, 32)
-			pg_configs = pgm.pgs
-			opts = pg_configs[0][0]
-			fun.options(**opts).remote()
-		```
-	Args:
-		num_pgs: number of placement groups to be created
-		instance_cpus: number of cpus per instance
-	"""
-	def __init__(self, num_pgs: int, instance_cpus: int, time_out: Optional[float] = None):
-		#self._pg_configs =self._config(num_pgs, instance_cpus, time_out)
-		self._pg_configs = ray.get([_config.remote(instance_cpus) for _ in range(num_pgs)])
-	@property
-	def pgs(self):
-		return self._pg_configs
-
-@ray.remote
-def _config(instance_cpus: int, time_out: Optional[float] = None) -> Tuple[Dict[str,Any], Dict[str,Any]]:
-	pg_config = None
-	try:
-		opts ={}
-		cluster_resources={}
-		bundle1={'CPU': instance_cpus} # hardcode for now
-		pg = placement_group([bundle1], strategy="PACK")
-		ray.get(pg.ready(), timeout=time_out)
-		if not pg:
-			return
-		opts = {"scheduling_strategy":PlacementGroupSchedulingStrategy(
-			placement_group=pg, placement_group_capture_child_tasks=True)
-		}
-		pg_id = placement_group_table(pg)['placement_group_id']
-		#print("pg id{}".format(pg_id))
-		pg_details = get_placement_group(pg_id)
-		#print("pgs-{}".format(pgs))
-		bundles = pg_details['bundles']
-		node_ids =[]
-		for bd in bundles:
-			node_ids.append(bd['node_id'])
-		#query available resources given list of node id
-		all_nodes_available_res = ray._private.state.state._available_resources_per_node()
-		pg_res = {'CPU':0,'memory':0,'object_store_memory':0,'node_id':[]}
-		for node_id in node_ids:
-			if node_id in all_nodes_available_res:
-				v = all_nodes_available_res[node_id]
-				node_detail = get_node(node_id)
-				pg_res['CPU']+=node_detail['resources_total']['CPU']
-				pg_res['memory']+=v['memory']
-				pg_res['object_store_memory']+=v['object_store_memory']
-					#pg_res['node_id'].append(node_id)
-		cluster_resources['CPU'] = int(pg_res['CPU'])
-		cluster_resources['memory'] = float(pg_res['memory'])
-		cluster_resources['object_store_memory'] = float(pg_res['object_store_memory'])
-		#cluster_resources['node_id'] = pg_res['node_id']
-		#cluster_cpus = cluster_resources['CPU']
-		pg_config=[opts,cluster_resources]
-		print("pg has resources:{}".format(cluster_resources))
-
-	except Exception as e:
-		print("Error in creating pg:{}".format(e))
-		logger.error(f"placement group error{e}")
-		pass
-	return pg_config
-

deltacat/autoscaler/utils.py

@@ -1,69 +0,0 @@
-import os
-import subprocess
-from typing import Any, Optional, List
-
-import ray
-
-
-def run_cmd(cmd: str,
-            background_process: bool = False,
-            stdout: Optional[Any] = subprocess.DEVNULL,
-            stderr: Optional[Any] = subprocess.STDOUT) -> None:
-    cmd_list = cmd.split(" ")
-    if background_process:
-        cmd_list = ["nohup"] + cmd_list
-        subprocess.Popen(cmd_list,
-                         stdout=stdout,
-                         stderr=stderr)
-        return
-    else:
-        exit_code = subprocess.call(cmd_list, stdout=stdout, stderr=stderr)
-        assert exit_code == 0, f"`{cmd}` failed. Exit code: {exit_code}"
-
-
-def ray_submit(cluster_cfg: str,
-               path_to_script: str,
-               script_arguments: Optional[List[str]] = None,
-               background_process: bool = False,
-               start_cluster: bool = True,
-               stop_cluster: bool = True,
-               stdout: Optional[Any] = subprocess.DEVNULL,
-               stderr: Optional[Any] = subprocess.STDOUT) -> None:
-    cluster_args = []
-    if start_cluster:
-        cluster_args.append("--start")
-    if stop_cluster:
-        cluster_args.append("--stop")
-
-    if script_arguments is None:
-        script_arguments = []
-
-    script_arguments_str = " ".join(script_arguments)
-
-    cmd = f"ray submit --log-style record --no-config-cache {' '.join(cluster_args)} {cluster_cfg} {path_to_script}"
-    if script_arguments:
-        cmd = f"{cmd} -- {script_arguments_str}"
-
-    run_cmd(cmd, background_process=background_process, stdout=stdout, stderr=stderr)
-    print(f"Submitted script on Ray cluster '{cluster_cfg}' with command '{cmd}'")
-
-
-def ray_up(cluster_cfg: str) -> None:
-    print(f"Starting Ray cluster '{cluster_cfg}'")
-    run_cmd(f"ray up {cluster_cfg} -y --no-config-cache --no-restart")
-    print(f"Started Ray cluster '{cluster_cfg}'")
-
-
-def get_head_node_ip(cluster_cfg: str) -> str:
-    print(f"Getting Ray cluster head node IP for '{cluster_cfg}'")
-    proc = subprocess.run(
-        f"ray get-head-ip {cluster_cfg}",
-        shell=True,
-        capture_output=True,
-        text=True,
-        check=True)
-    # the head node IP should be the last line printed to stdout
-    head_node_ip = proc.stdout.splitlines()[-1]
-    print(f"Ray cluster head node IP for '{cluster_cfg}': {head_node_ip}")
-    return head_node_ip
-

deltacat-0.1.8.dist-info/RECORD

@@ -1,131 +0,0 @@
-deltacat/__init__.py,sha256=PykA9TJ4ofPC4lwnnzyAgabk_POjYX8QZ-b1TOwe8IY,1675
-deltacat/constants.py,sha256=ZGSRdqQQEIuQGO_Qwkl3tQxdZGVl4oLH01tCdXvyURo,1092
-deltacat/exceptions.py,sha256=x7qem7FLujXf-DzPsNcQ-XYkW3cF3A0YGIbxkcpz0Mw,146
-deltacat/logs.py,sha256=ZvMw7mhQZTNZH1Czwd_rW1OAnnFiQpogN4441UjWVQo,3879
-deltacat/autoscaler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/autoscaler/node_group.py,sha256=On7UffaEsl_iSFTY5biAakECRYCou8r6P661WzgeUqU,8026
-deltacat/autoscaler/utils.py,sha256=76bcUt2tEu6fxUpKBQwyWr_Ea2Xnwvjff2OxvLhQ0sc,2368
-deltacat/autoscaler/events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/autoscaler/events/dispatcher.py,sha256=T2oa9wmm3bcCmmoBmj8fjZojR9m0aTe2OVp8uKE5ZMQ,3792
-deltacat/autoscaler/events/event_store.py,sha256=26uggtK8DbGv4tflW80z32KKwGzvfNYoNeYBfPqGgcw,1764
-deltacat/autoscaler/events/exceptions.py,sha256=1vdhgrCaXd10-NNM5Etem-q-041ZJBzom0IXKSfJpQk,97
-deltacat/autoscaler/events/processor.py,sha256=vW9K0paNBXaNQyJbRxjTzc4r4GbMmM7tyVIWXoUNWWs,7655
-deltacat/autoscaler/events/session_manager.py,sha256=Hb1zpNrc3r2tPFTJMrPW8c5oDF0XtsxSpJM1OcK__Wk,598
-deltacat/autoscaler/events/states.py,sha256=AAMcIuH9lNSZ3uj7UUQgE9CgCs-rph1dXy0fQ0r-bNE,2080
-deltacat/autoscaler/events/workflow.py,sha256=4o6AWguNiZB2hO6H7vIqTvYWxoVIQKi8xwWIcU2n8NI,2151
-deltacat/autoscaler/events/compaction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/autoscaler/events/compaction/cluster.py,sha256=CPVG4gOaQonUX4uXpM4Ax8F_Wz826yG3SesqPrYbfvM,3323
-deltacat/autoscaler/events/compaction/dispatcher.py,sha256=8PcjIkR930-hMqP1kpJXbeMIj41ezX4gQop8DkQEvTU,1176
-deltacat/autoscaler/events/compaction/input.py,sha256=4lYsUSmsxvB4DbkdEJ3SMFxO8avJW8qakhkEaN69Wkk,1176
-deltacat/autoscaler/events/compaction/process.py,sha256=0iyqngVv-Ib0VIQRQH8U-Q29Zl90rpzwb3TxWNTtWFQ,1161
-deltacat/autoscaler/events/compaction/session_manager.py,sha256=gO2nNPTAorQzCaQzpCYXcstlU8aZLOEPH95d_Et4ci8,598
-deltacat/autoscaler/events/compaction/utils.py,sha256=k_x4wBo5WvzBMV21EwFbNnqp1NyirR9LZc9Ez9hG6k8,10073
-deltacat/autoscaler/events/compaction/workflow.py,sha256=dYEJBpiJ66XIkinD-g28JM018UMR5wUN2DLXfW-VWHI,18182
-deltacat/autoscaler/events/compaction/collections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/autoscaler/events/compaction/collections/partition_key_value.py,sha256=kc5regg9DIKmFAlEriGYf6QoIna63eIMPSBhcVCccFk,787
-deltacat/autoscaler/events/dynamodb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/autoscaler/events/dynamodb/event_store.py,sha256=_2_nHcpLOqml7pDowOy5hwbmEzdwzG_OERpCApS6I10,5686
-deltacat/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/aws/clients.py,sha256=5i2F-o3fRI4JzaYw-2015lwf1fYs_Zir6JnSPQK5Mjo,1936
-deltacat/aws/constants.py,sha256=jbcUubyhkMOmDh_XpTljBX-0hnhYJduetJcLqRmpfl4,204
-deltacat/aws/s3u.py,sha256=f-Q-L4mSxKgBGiT2X5JuF423GHkYGhLI61pymR8u6hg,18817
-deltacat/aws/redshift/__init__.py,sha256=pJ0pHF2extLnNKyt7bhCVBsf61Ri-M-eoejqsAhlJlU,247
-deltacat/aws/redshift/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/aws/redshift/model/manifest.py,sha256=mMsUgB2YxtmvRuJg2YJozKbcPlAKHcWT6GB_7zyI9oo,9575
-deltacat/catalog/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/catalog/delegate.py,sha256=zde_eXYcQaUheXQcNz58BwcaXieYfeCXYoAuBis6Pqs,9272
-deltacat/catalog/interface.py,sha256=TTFHmbSWd9lUQx5T0RhOAddCU2HcQrXlN0dD-ewYs4M,6783
-deltacat/catalog/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/catalog/model/catalog.py,sha256=0nw-xk5qKl4xJC51U6IBPRB76pfwMkr3vmNRn25VRdE,2270
-deltacat/catalog/model/table_definition.py,sha256=pUc8sHSjhD3ifGrUeWevruTNsNUD0xtaPcc_sddTjjo,697
-deltacat/compute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/__init__.py,sha256=MLh6Y9yP0piKMW5Xh9JdS-qJ7PVaJXpzk13mLLzZxig,1103
-deltacat/compute/compactor/compaction_session.py,sha256=40hsNMr_VfMnbjNvUZuU2AUdBepMIDSh7if7Xp9m3GI,26159
-deltacat/compute/compactor/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/model/delta_annotated.py,sha256=EXxV-bdwhCqzjzxSy4GAH7xFzC9g49VNZXkrIzjxdb4,7599
-deltacat/compute/compactor/model/delta_file_envelope.py,sha256=5VeD4krZpI3mWGK1odwvcRz9CK5_IbutN__SLrAv2gQ,1855
-deltacat/compute/compactor/model/delta_file_locator.py,sha256=_WMa37EVFmpR-BERBEKY8-Xh3chtTUs5hKfgNsx65jc,1736
-deltacat/compute/compactor/model/materialize_result.py,sha256=96OnkdwZ6jhLc4QWd1PLNUbxnhaCXt0qyOW7xl_RU8M,1267
-deltacat/compute/compactor/model/primary_key_index.py,sha256=uVFCef5vIYTdvtSN4T8iP80iQNEahH8qBPZmNC6ybc8,10524
-deltacat/compute/compactor/model/pyarrow_write_result.py,sha256=YjHklyhJm_uZIjW45Xj0prl1pLRCAPjlPG4ypPSa8s8,1343
-deltacat/compute/compactor/model/round_completion_info.py,sha256=rElYyqdavQhpzBDUat1v63XMKbbbmn8RfN7ezoVl_u0,2755
-deltacat/compute/compactor/model/sort_key.py,sha256=tU9XJa455wuvssb3oeuYwPagPMU55TT5iH6TIZD8TK0,4062
-deltacat/compute/compactor/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/steps/dedupe.py,sha256=TXnfPoPlTMs6duh-uDovCWqTmyr6o8a2K0YTbyyZ4m4,16277
-deltacat/compute/compactor/steps/hash_bucket.py,sha256=hu4cG9p73All4HkSFF3FlTPJigQhv5x3vtWUJLCUuoo,6636
-deltacat/compute/compactor/steps/materialize.py,sha256=UJL_V9rZX5KvD6hRR3SNQ5rKXQzp00lsUu5lUpllq28,7272
-deltacat/compute/compactor/steps/rehash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/steps/rehash/rehash_bucket.py,sha256=h5w-lNTiaufIO_gbMVnCn3vJ4s9RdT9_NzkeyX9aIQg,1794
-deltacat/compute/compactor/steps/rehash/rewrite_index.py,sha256=n743Xo1j_eUl22_AFEhTfrCzYSydwpXFaFCfruJr4Kk,1869
-deltacat/compute/compactor/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor/utils/io.py,sha256=1E0MG_mxk_RGzl4I5xYUSuyWXAaOuWkBSxOX4khx0LY,9678
-deltacat/compute/compactor/utils/primary_key_index.py,sha256=H2odhlzplrgL1LcwelaRoVNFHNy3p_1NgFW0dfaSesw,10864
-deltacat/compute/compactor/utils/round_completion_file.py,sha256=uvf-pyIQCVmfpM0Ew1qjZ7OVK4-jJifuu-u_dverEPw,2116
-deltacat/compute/compactor/utils/system_columns.py,sha256=1M4JHwqDIRnfQaqvPz8_zBw05de45Db06To-3wiUVUk,7003
-deltacat/compute/metastats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/metastats/meta_stats.py,sha256=kCRWfQ2zDVrjfIvhE1S6B0ShRPn5bRQA-z8r8VE2Oco,20588
-deltacat/compute/metastats/stats.py,sha256=LI9ndlwfAs7Ad-MsKaBeGL92JieRh8a54RxwXfRqDCU,7375
-deltacat/compute/metastats/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/metastats/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/metastats/model/partition_stats_dict.py,sha256=o7BlH-Eyv9RzesLTw7OoTKWqkHFI9bE0ZuefjTr3viA,1405
-deltacat/compute/metastats/model/stats_cluster_size_estimator.py,sha256=3965WMAHQAzUcQSnK3UaW-ULGIC7qibaz0frl7h0DdI,2766
-deltacat/compute/metastats/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/metastats/utils/constants.py,sha256=bFUPKmR3FkjEnwpHuToQYZ9QcHqYpd4OMMSwVwnJcaA,869
-deltacat/compute/metastats/utils/io.py,sha256=NBEu4wkS8wNUYXULHXWGq1fEscmEneNNlJgHUgtNxnk,8531
-deltacat/compute/metastats/utils/pyarrow_memory_estimation_function.py,sha256=BYdnNZywoEoZIcbikuWYU97Ox3BRdPJExNUL10QnPkY,1135
-deltacat/compute/metastats/utils/ray_utils.py,sha256=-SDouyx5O0Qt4ZiGFmU0lGHvWZoXO3w5BS_Vx39gJa4,4591
-deltacat/compute/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/stats/basic.py,sha256=fL5UgyHKeUdQqzr1lXstbHmWSIvawTTXk5pRmhyH-HQ,9415
-deltacat/compute/stats/types.py,sha256=cp0lT8nITTKbnkc03OysRjXfcfXzQml9a4wqCnR6kqs,215
-deltacat/compute/stats/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/stats/models/delta_column_stats.py,sha256=_m-fGbx2njONr9N2ihkIajUzVvmy8weDG5BLJdMaoQU,3296
-deltacat/compute/stats/models/delta_stats.py,sha256=yzxum2boP5c4cTSNaLOSgdioQ4ZPtSoMX_Ju3k-4MY4,8711
-deltacat/compute/stats/models/delta_stats_cache_result.py,sha256=ga_by81TNDpptjYYUzpQHVRCR95_NnZ1a59apmvVBUo,1609
-deltacat/compute/stats/models/manifest_entry_stats.py,sha256=vGTOq_a1XFFf3N_rcB4QXTHuEx-T3P5KwJllrKi7zuw,2363
-deltacat/compute/stats/models/stats_result.py,sha256=j3bjU8LdLbTkpM4ZZojQ70WfqHsXFNftJG2PwKReSRg,3753
-deltacat/compute/stats/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/stats/utils/intervals.py,sha256=PmbE1856k_y0p6lNrQ3rNC_RBT8PROA2wQRFVM2s8P8,3049
-deltacat/compute/stats/utils/io.py,sha256=H-xIrWOqN4JSDuo3imrKDEyU_xDrfKU2tFwdOg7Jne4,8587
-deltacat/compute/stats/utils/manifest_stats_file.py,sha256=rc3BdQ-QjgRSz6vBGw_x3shShnkNVeVVMEzs8n9Ir6A,3811
-deltacat/io/__init__.py,sha256=4fQUUNSj8pnpFw4oF6CuDbhizj5JU0Jml2qQd-lVUvA,153
-deltacat/io/dataset.py,sha256=DG1TfhAX1dWYVcUAryOgLyqgDQ71syVRvkFxPS0BJjQ,3821
-deltacat/io/read_api.py,sha256=kkcclEshS5MEEI6gzJ0HkcIug2ph_DE8aUdBddUaRPU,7109
-deltacat/io/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/io/aws/redshift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/io/aws/redshift/redshift_datasource.py,sha256=BWlQoAVnGi8Urj5rF5ZOePWy0O-xxOgJIwLt-f-s6BM,22765
-deltacat/storage/__init__.py,sha256=doAx2Ojk8BJik80crGrlX0rph8HKk2Cm5JJ6HqfP5qc,1337
-deltacat/storage/interface.py,sha256=d2b3Y1caGuqS-QaSpaCw6gnAkSCZgQfGEWKuVIocHIE,22080
-deltacat/storage/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/storage/model/delta.py,sha256=1fXuIOq_S4u164fVnFe58jVKR5NTARP2bWqAZOkEpOY,13912
-deltacat/storage/model/list_result.py,sha256=zGa32B3c98qtxRJq376h3eHQmQLulhhOna0G8psPsJY,2445
-deltacat/storage/model/locator.py,sha256=1S7szmDSx-R4Z3arFNILOvS4t7dF7_rJNV9fHyRc3G4,1296
-deltacat/storage/model/namespace.py,sha256=pvz4NNU5W4l8LbLGJPbmPb9uwL6rlTr64yAtwJ7GHVs,2108
-deltacat/storage/model/partition.py,sha256=XcYxzfW3adTJYB8ZkeirCdZ41UhoBH8CojZ84KUJo40,11165
-deltacat/storage/model/stream.py,sha256=gLzpscjeU4EHGowXDyJMqstN64v57FzGlyDdZJTwuwQ,7818
-deltacat/storage/model/table.py,sha256=zTlM1B2R7fpN5F0ktA_KpE2DlmQBSn8iNOpLI9PP65w,4252
-deltacat/storage/model/table_version.py,sha256=qDCafR53oMBDUMcg6sxkGOFZdWyf7oL1sew5VKobIss,7086
-deltacat/storage/model/types.py,sha256=u2yCTqxzoQz8pcrzr8uD0xXP35kPisQKcbDgzac1YQ8,1579
-deltacat/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/tests/stats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/tests/stats/test_intervals.py,sha256=NhKBqTgTRcVPqrExlJNrVHyToeaA9dX01UwJsKzQZMM,2137
-deltacat/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/types/media.py,sha256=S0cYjbcRSN8I9EewZvmezYTWbIy01Sa2pLl67hMThwE,2186
-deltacat/types/tables.py,sha256=KCXmpv-hVRbsySGDaFM1gTsygociRx0TkrxLY1vNNNc,3814
-deltacat/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/utils/common.py,sha256=0yenkHroJiQjeenXZnNSDSD06-KJuBIsw2GAMqqQSKI,1449
-deltacat/utils/numpy.py,sha256=D1dCa7xTOlZXzxDhaETzl1c8zJNxGpBr_-_Cb5yzXAI,2094
-deltacat/utils/pandas.py,sha256=SBEnH2eQgjrQkdW6Dvk3Ky3reTI0xYRGFE2JIOsZqaA,10067
-deltacat/utils/performance.py,sha256=GsHuRG8Zi6iVmIC9F4fXUDbEFk03fErVJy8JjYCWsUE,670
-deltacat/utils/placement.py,sha256=knanJlEMSGMA3t-UISsLTUP-fQ9CzzR1LZO29L2HfB4,8823
-deltacat/utils/pyarrow.py,sha256=mc93BdFip-0aLdLuQtNXlf7LoFX2k5txdOhWYehq1-g,10611
-deltacat/utils/ray_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/utils/ray_utils/collections.py,sha256=2B90lyLulxS7tBMkyzLAVC1fIeqYspxuaVBeXGveYlE,1950
-deltacat/utils/ray_utils/concurrency.py,sha256=2L6VVQrjTN1DTNBL8B4xy5Ty6lmO6G_M8vN9TDJuLrA,4906
-deltacat/utils/ray_utils/dataset.py,sha256=JPonxxxmDuAUiYqmBBTM2hyXHPggNGgp3QvsUxSjvNI,3319
-deltacat/utils/ray_utils/performance.py,sha256=v0JHrjlTGw4-ypzy_ZBlY4mOQN9o9euQiwc6IWk7-bY,515
-deltacat/utils/ray_utils/runtime.py,sha256=8Z7WlIYylij93vhhwUf3bijrpGKCEpEKlXVI5KCC1ps,4810
-deltacat-0.1.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-deltacat-0.1.8.dist-info/METADATA,sha256=s9S-3IUuKC_fjg5w9M3ODpRaQvy_YdVRePQo-RyJAvM,1414
-deltacat-0.1.8.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-deltacat-0.1.8.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
-deltacat-0.1.8.dist-info/RECORD,,