rdxz2-utill 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

utill/my_pg.py

@@ -17,27 +17,35 @@ class PG:
         connection=None,
         config_source: str | dict = PG_FILENAME,
         autocommit: bool = True,
-        application_name: str = 'utill',
+        application_name: str = "utill",
         row_factory: psycopg.rows = psycopg.rows.tuple_row,
     ) -> None:
         # Evaluate config source
         if isinstance(config_source, str):
             if not os.path.exists(config_source):
-                raise ValueError(f'Config source file not found: {config_source}, create one with \'utill init\'')
+                raise ValueError(
+                    f"Config source file not found: {config_source}, create one with 'utill init'"
+                )
             if connection is None:
-                raise ValueError('Connection name must be provided when using file source!')
-            conf = json.loads(open(os.path.expanduser(config_source)).read())[connection]
+                raise ValueError(
+                    "Connection name must be provided when using file source!"
+                )
+            conf = json.loads(open(os.path.expanduser(config_source)).read())[
+                connection
+            ]
         elif isinstance(config_source, dict):
             conf = config_source
         else:
-            raise ValueError('Config source type must be either one of string / dictonary')
+            raise ValueError(
+                "Config source type must be either one of string / dictonary"
+            )
 
         (_, host, port) = establish_tunnel(conf)
         self.db_host = host
         self.db_port = port
-        self.db_username = conf['username']
-        self.db_password = conf['password']
-        self.db_name = conf['db']
+        self.db_username = conf["username"]
+        self.db_password = conf["password"]
+        self.db_name = conf["db"]
         self.conf = conf
 
         self.conn = None
@@ -45,12 +53,12 @@ class PG:
         self.row_factory = row_factory
 
         conninfo = {
-            'host': self.db_host,
-            'port': self.db_port,
-            'user': self.db_username,
-            'password': self.db_password,
-            'dbname': self.db_name,
-            'application_name': application_name,
+            "host": self.db_host,
+            "port": self.db_port,
+            "user": self.db_username,
+            "password": self.db_password,
+            "dbname": self.db_name,
+            "application_name": application_name,
         }
         self.dsn = psycopg.conninfo.make_conninfo(**conninfo)
         self.establish_connection(autocommit, row_factory)
@@ -64,7 +72,9 @@ class PG:
     def establish_connection(self, autocommit: bool, row_factory: psycopg.rows):
         self.conn = psycopg.connect(self.dsn, autocommit=autocommit)
         self.cursor = self.conn.cursor(row_factory=row_factory)
-        logger.debug(f'PG client open: {self.db_username}@{self.db_host}:{self.db_port}/{self.db_name}, autocommit={self.conn.autocommit}')
+        logger.debug(
+            f"PG client open: {self.db_username}@{self.db_host}:{self.db_port}/{self.db_name}, autocommit={self.conn.autocommit}"
+        )
 
     def change_autocommit(self, autocommit: bool):
         if autocommit == self.conn.autocommit:
@@ -78,33 +88,39 @@ class PG:
             self.establish_connection(self.conn.autocommit, self.row_factory)
 
         query = query.strip()
-        logger.debug(f'🔎 Query:\n{query}')
+        logger.debug(f"🔎 Query:\n{query}")
 
         return self.cursor.execute(query, params)
 
     def download_csv(self, query: str, file_path: str) -> None:
         query = dedent(
-            f'''
+            f"""
             COPY ({query})
             TO STDOUT
             WITH DELIMITER ','
             CSV HEADER;
-            '''
+            """
         )
-        logger.debug(f'🔎 Query:\n{query}')
-        with open(os.path.expanduser(file_path), 'wb') as f:
+        logger.debug(f"🔎 Query:\n{query}")
+        with open(os.path.expanduser(file_path), "wb") as f:
             with self.cursor.copy(query) as copy:
                 for data in copy:
                     f.write(data)
 
-    def pg_to_pg(self, pg: "PG", src_table_name: str, dst_table_name: str, cols: list[str] = None) -> None:
+    def pg_to_pg(
+        self, pg: "PG", src_table_name: str, dst_table_name: str, cols: list[str] = None
+    ) -> None:
         self.ensure_table_exists(src_table_name)
         pg.ensure_table_exists(dst_table_name)
 
-        tmp_filename = generate_random_string(alphanum=True) + '.csv'
-        cols_str = ','.join([f'"{x}"' for x in cols]) if (cols is not None and cols != []) else '*'
+        tmp_filename = generate_random_string(alphanum=True) + ".csv"
+        cols_str = (
+            ",".join([f'"{x}"' for x in cols])
+            if (cols is not None and cols != [])
+            else "*"
+        )
         try:
-            self.download_csv(f'SELECT {cols_str} FROM {src_table_name}', tmp_filename)
+            self.download_csv(f"SELECT {cols_str} FROM {src_table_name}", tmp_filename)
             pg.upload_csv(tmp_filename, dst_table_name)
         except:
             raise
@@ -112,15 +128,22 @@ class PG:
             os.remove(tmp_filename) if os.path.exists(tmp_filename) else None
 
     def ensure_table_exists(self, table_name: str) -> bool:
-        if not self.execute_query('''SELECT count(1) AS "cnt" FROM "information_schema"."tables" WHERE "table_schema" || '.' || "table_name" = %s;''', (table_name, )).fetchone()[0]:
-            raise Exception(f'Target table \'{table_name}\' not created, please create it first!')
-
-    def upload_tuples(self, cols: list[str], src_tuples: list[tuple], src_table_name: str) -> None:
+        if not self.execute_query(
+            """SELECT count(1) AS "cnt" FROM "information_schema"."tables" WHERE "table_schema" || '.' || "table_name" = %s;""",
+            (table_name,),
+        ).fetchone()[0]:
+            raise Exception(
+                f"Target table '{table_name}' not created, please create it first!"
+            )
+
+    def upload_tuples(
+        self, cols: list[str], src_tuples: list[tuple], src_table_name: str
+    ) -> None:
         self.ensure_table_exists(src_table_name)
 
-        cols_str = ','.join([f'"{x}"' for x in cols])
-        query = f'''COPY {src_table_name}({cols_str}) FROM STDIN'''
-        logger.debug(f'🔎 Query:\n{query}')
+        cols_str = ",".join([f'"{x}"' for x in cols])
+        query = f"""COPY {src_table_name}({cols_str}) FROM STDIN"""
+        logger.debug(f"🔎 Query:\n{query}")
         with self.cursor.copy(query) as copy:
             for row in src_tuples:
                 copy.write_row(row)
@@ -129,12 +152,12 @@ class PG:
         self.ensure_table_exists(dst_table_name)
 
         if len(src_data) == 0:
-            raise ValueError('No data to upload!')
+            raise ValueError("No data to upload!")
 
         cols = src_data[0].keys()
-        cols_str = ','.join([f'"{x}"' for x in cols])
-        query = f'''COPY {dst_table_name}({cols_str}) FROM STDIN'''
-        logger.debug(f'🔎 Query:\n{query}')
+        cols_str = ",".join([f'"{x}"' for x in cols])
+        query = f"""COPY {dst_table_name}({cols_str}) FROM STDIN"""
+        logger.debug(f"🔎 Query:\n{query}")
         with self.cursor.copy(query) as copy:
             for row in src_data:
                 copy.write_row(tuple(row[col] for col in cols))
@@ -144,39 +167,46 @@ class PG:
 
         self.ensure_table_exists(dst_table_name)
 
-        cols_str = ','.join([f'"{x}"' for x in next(csv.reader(open(src_filename, 'r')))])
+        cols_str = ",".join(
+            [f'"{x}"' for x in next(csv.reader(open(src_filename, "r")))]
+        )
         query = dedent(
-            f'''
+            f"""
             COPY {dst_table_name}({cols_str})
             FROM STDIN
             DELIMITER ','
             CSV HEADER;
-            '''
+            """
         )
-        logger.debug(f'🔎 Query:\n{query}')
-        with open(os.path.expanduser(src_filename), 'r') as f:
+        logger.debug(f"🔎 Query:\n{query}")
+        with open(os.path.expanduser(src_filename), "r") as f:
             with self.cursor.copy(query) as copy:
                 while data := f.read(1024):
                     copy.write(data)
 
-    def create_index(self, table_name: str, index: str | list[str], unique: bool = False) -> None:
+    def create_index(
+        self, table_name: str, index: str | list[str], unique: bool = False
+    ) -> None:
         try:
             index = index if type(index) == list else [index]
-            indexes = ','.join([f'"{x}"' for x in index])
-            self.execute_query(f'CREATE {"UNIQUE " if unique else ""}INDEX ON "{table_name}" ({indexes});', return_df=False)
+            indexes = ",".join([f'"{x}"' for x in index])
+            self.execute_query(
+                f'CREATE {"UNIQUE " if unique else ""}INDEX ON "{table_name}" ({indexes});',
+                return_df=False,
+            )
         except Exception as e:
             self.rollback()
             raise e
 
     def rollback(self):
         self.conn.rollback()
-        logger.debug('🚫 Transaction rollback')
+        logger.debug("🚫 Transaction rollback")
 
     def commit(self):
         self.conn.commit()
-        logger.debug('✅ Transaction commit')
+        logger.debug("✅ Transaction commit")
 
     def close(self):
         self.cursor.close()
         self.conn.close()
-        logger.debug('PG client close')
+        logger.debug("PG client close")

utill/my_queue.py

@@ -3,12 +3,19 @@ from typing import Callable
 import concurrent.futures
 import queue
 
+
 class StreamingQ:
-    def __init__(self, producer_func: Callable, producer_args: tuple, consumer_func: Callable, max_queue_size: int = 0):
+    def __init__(
+        self,
+        producer_func: Callable,
+        producer_args: tuple,
+        consumer_func: Callable,
+        max_queue_size: int = 0,
+    ):
         self.producer_func = producer_func
         self.producer_args = producer_args
         self.consumer_func = consumer_func
-        
+
         # Use maxsize for backpressure control (0 = unlimited)
         self.q = queue.Queue(maxsize=max_queue_size)
 
@@ -17,68 +24,68 @@ class StreamingQ:
         Execute producer and consumer with true streaming using generators.
         Yields consumer results as they become available.
         """
+
         def producer():
             try:
                 for item in self.producer_func(*self.producer_args):
                     self.q.put(item)
-                    logger.debug(f'🌾 Produced {item}')
+                    logger.debug(f"🌾 Produced {item}")
             except Exception as e:
-                logger.error(f'Producer error: {e}')
-                self.q.put(('ERROR', e))
+                logger.error(f"Producer error: {e}")
+                self.q.put(("ERROR", e))
             finally:
                 # Signal end of production
                 self.q.put(None)
-                logger.debug('🌾 Producer finished')
+                logger.debug("🌾 Producer finished")
 
         def consumer():
             while True:
                 item = self.q.get()
-                
+
                 if item is None:
                     # End of stream signal
                     self.q.task_done()
                     break
-                
-                if isinstance(item, tuple) and item[0] == 'ERROR':
+
+                if isinstance(item, tuple) and item[0] == "ERROR":
                     # Propagate producer error
                     self.q.task_done()
                     raise item[1]
-                
+
                 try:
                     # Unpack item if it's a tuple, otherwise pass as single arg
                     if isinstance(item, tuple):
                         result = self.consumer_func(*item)
                     else:
                         result = self.consumer_func(item)
-                    
+
                     self.q.task_done()
-                    logger.debug(f'🔥 Consumed {item} -> {result}')
+                    logger.debug(f"🔥 Consumed {item} -> {result}")
                     yield result
-                
+
                 except Exception as e:
                     self.q.task_done()
-                    logger.error(f'Consumer error processing {item}: {e}')
+                    logger.error(f"Consumer error processing {item}: {e}")
                     raise
 
         with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
             # Start producer in background
             future_producer = executor.submit(producer)
-            
+
             try:
                 # Yield results as they become available
                 for result in consumer():
                     yield result
-                
+
                 # Wait for producer to complete
                 future_producer.result()
-                
+
             except Exception as e:
                 # Cancel producer if consumer fails
                 future_producer.cancel()
                 raise
 
 
-
 class ThreadingQ:
     def __init__(self) -> None:
         self.q = queue.Queue()
@@ -98,8 +105,14 @@ class ThreadingQ:
         return self
 
     def execute(self):
-        if not all([self.producer_func is not None, self.producer_args is not None, self.consumer_func is not None]):
-            raise Exception('Producer and Consumer functions must be defined!')
+        if not all(
+            [
+                self.producer_func is not None,
+                self.producer_args is not None,
+                self.consumer_func is not None,
+            ]
+        ):
+            raise Exception("Producer and Consumer functions must be defined!")
 
         def producer():
             results = []
@@ -107,7 +120,7 @@ class ThreadingQ:
             for item in self.producer_func(*self.producer_args):
                 self.q.put(item)
                 results.append(item)
-                logger.debug(f'🌾 Produced {item}')
+                logger.debug(f"🌾 Produced {item}")
 
             self.q.put(None)
             return results
@@ -124,7 +137,7 @@ class ThreadingQ:
                 results.append(result)
 
                 self.q.task_done()
-                logger.debug(f'🔥 Consumed {item}')
+                logger.debug(f"🔥 Consumed {item}")
 
             return results
 
@@ -134,8 +147,8 @@ class ThreadingQ:
             self.future_consumer = executor.submit(consumer)
 
             producer_result = self.future_producer.result()
-            logger.debug('✅ Producer done')
+            logger.debug("✅ Producer done")
             consumer_result = self.future_consumer.result()
-            logger.debug('✅ Consumer done')
+            logger.debug("✅ Consumer done")
 
         return producer_result, consumer_result

utill/my_string.py

@@ -4,17 +4,35 @@ import re
 import string
 
 
-def generate_random_string(length: int = 4, alphanum: bool = False): return ''.join(random.choice(string.ascii_letters + string.digits + (r'!@#$%^&*()-=_+[]{};\':",./<>?' if not alphanum else '')) for _ in range(length))
+def generate_random_string(length: int = 4, alphanum: bool = False):
+    return "".join(
+        random.choice(
+            string.ascii_letters
+            + string.digits
+            + (r'!@#$%^&*()-=_+[]{};\':",./<>?' if not alphanum else "")
+        )
+        for _ in range(length)
+    )
 
 
-def replace_nonnumeric(string: str, replace: str) -> str: return re.sub('[^0-9a-zA-Z]+', replace, string)
+def replace_nonnumeric(string: str, replace: str) -> str:
+    return re.sub("[^0-9a-zA-Z]+", replace, string)
 
 
-def mask(string: str, mask_length_min: int = 5, mask_length_max: int = 50, display_length: int = 5) -> str:
+def mask(
+    string: str,
+    mask_length_min: int = 5,
+    mask_length_max: int = 50,
+    display_length: int = 5,
+) -> str:
     if not string:
         mask_length = mask_length_min
     else:
         hash_value = int(hashlib.sha256(string.encode()).hexdigest(), 16)
-        mask_length = mask_length_min + (hash_value % (mask_length_max - mask_length_min + 1))
+        mask_length = mask_length_min + (
+            hash_value % (mask_length_max - mask_length_min + 1)
+        )
 
-    return ('*' * mask_length) + (string[(-display_length if len(string) > display_length else -1):])
+    return ("*" * mask_length) + (
+        string[(-display_length if len(string) > display_length else -1) :]
+    )

utill/my_style.py

@@ -1,24 +1,26 @@
 class Styles:
-    NONE = '\033[0m'
-    ITALIC = '\033[3m'
-    BOLD = '\033[1m'
-    UNDERLINE = '\033[4m'
+    NONE = "\033[0m"
+    ITALIC = "\033[3m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
 
 
 class Colors:
-    HEADER = '\033[95m'
-    OKBLUE = '\033[94m'
-    OKCYAN = '\033[96m'
-    OKGREEN = '\033[92m'
-    WARNING = '\033[93m'
-    RED = '\033[91m'
-    BOLD = '\033[1m'
-    UNDERLINE = '\033[4m'
-
-
-def make_style(styles_or_colors: list[Styles | Colors] | Styles | Colors, string: str) -> str:
+    HEADER = "\033[95m"
+    OKBLUE = "\033[94m"
+    OKCYAN = "\033[96m"
+    OKGREEN = "\033[92m"
+    WARNING = "\033[93m"
+    RED = "\033[91m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+
+def make_style(
+    styles_or_colors: list[Styles | Colors] | Styles | Colors, string: str
+) -> str:
     if type(styles_or_colors) == list:
-        return ''.join(styles_or_colors) + string + Styles.NONE
+        return "".join(styles_or_colors) + string + Styles.NONE
     else:
         return styles_or_colors + string + Styles.NONE
 

utill/my_tunnel.py

@@ -3,7 +3,7 @@ import socket
 from loguru import logger
 from sshtunnel import SSHTunnelForwarder
 
-LOCALHOST = '127.0.0.1'
+LOCALHOST = "127.0.0.1"
 
 
 def _get_random_port() -> int:
@@ -12,7 +12,15 @@ def _get_random_port() -> int:
     return s.getsockname()[1]
 
 
-def start_tunnel(host: str, port: int, user: str, key: str, target_host: str, target_port: int, local_port: int = None) -> int:
+def start_tunnel(
+    host: str,
+    port: int,
+    user: str,
+    key: str,
+    target_host: str,
+    target_port: int,
+    local_port: int = None,
+) -> int:
     local_port = local_port or _get_random_port()
 
     tunnel = SSHTunnelForwarder(
@@ -29,14 +37,26 @@ def start_tunnel(host: str, port: int, user: str, key: str, target_host: str, ta
 
 
 def establish_tunnel(conf: dict, local_port: int = None) -> tuple:
-    using_tunnel = bool(conf.get('tunnel_host'))
-    local_host = LOCALHOST if using_tunnel else conf['host']
-
-    z = start_tunnel(conf['tunnel_host'], conf['tunnel_port'], conf['tunnel_username'], conf['tunnel_key'], conf['host'], conf['port'], local_port=local_port)\
-        if using_tunnel\
-        else (None, local_host, conf['port'])
+    using_tunnel = bool(conf.get("tunnel_host"))
+    local_host = LOCALHOST if using_tunnel else conf["host"]
+
+    z = (
+        start_tunnel(
+            conf["tunnel_host"],
+            conf["tunnel_port"],
+            conf["tunnel_username"],
+            conf["tunnel_key"],
+            conf["host"],
+            conf["port"],
+            local_port=local_port,
+        )
+        if using_tunnel
+        else (None, local_host, conf["port"])
+    )
 
     if using_tunnel:
-        logger.debug(f'🛣️  Tunnel established: {conf["host"]}:{conf["port"]} --> {conf["tunnel_username"]}@{conf["tunnel_host"]} --> {z[1]}:{z[2]}')
+        logger.debug(
+            f'🛣️  Tunnel established: {conf["host"]}:{conf["port"]} --> {conf["tunnel_username"]}@{conf["tunnel_host"]} --> {z[1]}:{z[2]}'
+        )
 
     return z

utill/my_xlsx.py

@@ -6,16 +6,19 @@ from loguru import logger
 
 def xlsx_to_csv(filename: str, sheet: str):
     con = duckdb.connect()
-    return con.execute('install spatial;')\
-        .execute('load spatial;')\
-        .execute(f'select * from st_read(\'{filename}\', layer=\'{sheet}\');')\
+    return (
+        con.execute("install spatial;")
+        .execute("load spatial;")
+        .execute(f"select * from st_read('{filename}', layer='{sheet}');")
         .fetchall()
+    )
 
 
 def csv_to_xlsx(filename: str, output_file_path: str):
-    logger.info(f'Converting csv \'{filename}\' into xlsx \'{output_file_path}\' ...')
+    logger.info(f"Converting csv '{filename}' into xlsx '{output_file_path}' ...")
     con = duckdb.connect()
-    con.execute('install spatial;')\
-        .execute('load spatial;')\
-        .execute(f'set threads to {multiprocessing.cpu_count()};')\
-        .execute(f'copy \'{filename}\' to \'{output_file_path}\' with(format gdal, driver \'xlsx\')')
+    con.execute("install spatial;").execute("load spatial;").execute(
+        f"set threads to {multiprocessing.cpu_count()};"
+    ).execute(
+        f"copy '{filename}' to '{output_file_path}' with(format gdal, driver 'xlsx')"
+    )

rdxz2_utill-0.1.2.dist-info/RECORD

@@ -1,35 +0,0 @@
-rdxz2_utill-0.1.2.dist-info/licenses/LICENSE,sha256=PF9CUvzP8XFYopEAzrMzSCovF7RdBdscPqJCDC6KjPc,1073
-utill/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-utill/my_bq.py,sha256=Y2zNCx7V71N8iNNEE-IB3KQuQDUeV7ZQbLJ4jY-N12Q,25108
-utill/my_compare.py,sha256=619QbVk3GihWxen95yVnivKHkah8GgPTLGiSkgHxykw,886
-utill/my_const.py,sha256=88dOqn6NPQ5-hfRqdkew5POoAIyO91XXOGvN76oNsdo,251
-utill/my_csv.py,sha256=AT5sAbAlYqnAmNgQMTSqEueRXM4D42yNPb5C3Hedy6c,2921
-utill/my_datetime.py,sha256=8AUO9l_MSzdthRsgASuyGZpvjgpoQb9Lowt4goHjyqw,2129
-utill/my_dict.py,sha256=jPaPfdn4WYpm0uIBPiYFinpHhx1jXpFVDJ9npmvxGZQ,391
-utill/my_encryption.py,sha256=SCF7PPur39cW4RHidsRhw-9BZP-ymUH-6LZ9nAHJDsY,2105
-utill/my_env.py,sha256=E7XW3fuhxbDlFqmLPHrziJJZVRogzGh6rfQdyNV49f8,2130
-utill/my_file.py,sha256=-b6_dGDDBdS228kgwTYpmIa3vxW1c1TtWrLdzdlHjKY,1873
-utill/my_gcs.py,sha256=qFH47gQmk6_v0DajihymX7Xx1ZVp4xWuxDQh90PrY0g,3088
-utill/my_input.py,sha256=OyKLoutXpwISReltuL_Gw2oojv16tYWJqQpqabBOQx4,350
-utill/my_json.py,sha256=WgW6mavGhfs4h1N5XbhsDnRk2dbh_ttJWdJUj4iWDN4,1473
-utill/my_mb.py,sha256=IyrySs92TqtjBUvPMeUN3P2kRK8EttTFRPZsv5Cr-xw,15090
-utill/my_pg.py,sha256=J9USygc-oug4w7AkBacA9x043jHZrDfQPGFEqXavZAY,6799
-utill/my_queue.py,sha256=Qf3Nm_ZRoVD34oAoym8A9hoH9Y27kUHeWLhylAUj5Q4,4749
-utill/my_string.py,sha256=pINYFR1ligTyVZYzV8P_FolCsZQwYE1jaFNTuQ3XS_8,833
-utill/my_style.py,sha256=Wy6j4WL9RgGeX6cS9hhlOrufc9UC4UPTQ5UJa0ZJ3Yo,900
-utill/my_tunnel.py,sha256=uCpGtiG8AcRYiaN7rLnTulsZI4iFTRM8EHxwyAAfDrE,1292
-utill/my_xlsx.py,sha256=YcQRp6DC9girSS1fkUPVKsHspyQpr8JC8GymSSnRV-w,729
-utill/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-utill/cmd/_bq.py,sha256=MQGLIv_WBUBl2tf18bfYrAszx0Koa5kdTW1c8A5HDDg,520
-utill/cmd/_conf.py,sha256=DKl3IVVLp6-5P43tvh6bYmHR5rOL9XnKVuQ7kQJtzrc,1863
-utill/cmd/_enc.py,sha256=DBy3Iwa5DTtww7lgHPRLEilrYPrWDG1vRv5PO-YzNO8,997
-utill/cmd/_main.py,sha256=UJ_XTIGDO9XPIypgHhS81SJQ_8qy8JOyw98Or0Nb2x8,273
-utill/cmd/_pg.py,sha256=RVxEiSifyIwMDYDM69vt6WSLdVDr1cMzY6r4T2PzNRA,492
-utill/cmd/utill.py,sha256=TlHfiwOUcK1m58PrRCjX9sARiPYZUsoTk-KOTCOz1vM,3558
-utill/templates/mb.json,sha256=M46ZHSaSh4rbD_KGUViGr2B2ZV8_PC-O5Evqi35JK5g,59
-utill/templates/pg.json,sha256=LkJt0VV3zcyt7Tpn6gulsoVQgUc-9uImXOStvzu8cdU,271
-rdxz2_utill-0.1.2.dist-info/METADATA,sha256=6tzVkvnpQcGVE24Zn3Z__yGHJeyP-mopwN35cY_gMiw,4401
-rdxz2_utill-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rdxz2_utill-0.1.2.dist-info/entry_points.txt,sha256=9n5NWz5Wi9jDvYhB_81_4icgT5xABZ-QivHD8ibcafg,47
-rdxz2_utill-0.1.2.dist-info/top_level.txt,sha256=tuAYZoCsr02JYbpZj7I6fl1IIo53v3GG0uoj-_fINVk,6
-rdxz2_utill-0.1.2.dist-info/RECORD,,