rdxz2-utill 0.0.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

utill/my_pg.py

@@ -1,12 +1,12 @@
 import csv
 import json
 import os
+from textwrap import dedent
+
 import psycopg
 import psycopg.conninfo
 import psycopg.rows
-
 from loguru import logger
-from textwrap import dedent
 
 from .my_env import PG_FILENAME
 from .my_string import generate_random_string
@@ -19,27 +19,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
@@ -47,12 +55,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)
@@ -66,7 +74,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:
@@ -74,106 +84,131 @@ class PG:
 
         self.conn.autocommit = autocommit
 
-    def execute_query(self, query: str, *params):
+    def execute_query(self, query: str, params: tuple = None):
         # Make sure connection alive
         if self.conn.closed:
             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", source_table: str, target_table: str, cols: list[str] = None) -> None:
-        tmp_filename = generate_random_string() + '.csv'
-        cols_str = ','.join([f'"{x}"' for x in cols]) if (cols is not None and cols != []) else '*'
+    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 "*"
+        )
         try:
-            self.download_csv(f'SELECT {cols_str} FROM {source_table}', tmp_filename)
-            pg.upload_csv(tmp_filename, target_table)
+            self.download_csv(f"SELECT {cols_str} FROM {src_table_name}", tmp_filename)
+            pg.upload_csv(tmp_filename, dst_table_name)
         except:
             raise
         finally:
             os.remove(tmp_filename) if os.path.exists(tmp_filename) else None
 
-    def check_table_existence(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()['cnt']:
-            raise Exception(f'Target table \'{table_name}\' not created, please create it first!')
-
-    def upload_tuples(self, cols: list[str], tuples: list[tuple], table_name: str) -> None:
-        self.check_table_existence(table_name)
+    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:
+        self.ensure_table_exists(src_table_name)
 
-        cols_str = ','.join([f'"{x}"' for x in cols])
-        query = f'''COPY {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 tuples:
+            for row in src_tuples:
                 copy.write_row(row)
 
-    def upload_list_of_dict(self, data: list[dict], table_name: str) -> None:
-        self.check_table_existence(table_name)
+    def upload_list_of_dict(self, src_data: list[dict], dst_table_name: str) -> None:
+        self.ensure_table_exists(dst_table_name)
 
-        if len(data) == 0:
-            raise ValueError('No data to upload!')
+        if len(src_data) == 0:
+            raise ValueError("No data to upload!")
 
-        cols = data[0].keys()
-        cols_str = ','.join([f'"{x}"' for x in cols])
-        query = f'''COPY {table_name}({cols_str}) FROM STDIN'''
-        logger.debug(f'🔎 Query:\n{query}')
+        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}")
         with self.cursor.copy(query) as copy:
-            for row in data:
+            for row in src_data:
                 copy.write_row(tuple(row[col] for col in cols))
 
-    def upload_csv(self, file_path: str, table_name: str) -> None:
-        self.check_table_existence(table_name)
+    def upload_csv(self, src_filename: str, dst_table_name: str) -> None:
+        src_filename = os.path.expanduser(src_filename)
 
-        cols_str = ','.join([f'"{x}"' for x in next(csv.reader(open(file_path, 'r')))])
+        self.ensure_table_exists(dst_table_name)
+
+        cols_str = ",".join(
+            [f'"{x}"' for x in next(csv.reader(open(src_filename, "r")))]
+        )
         query = dedent(
-            f'''
-            COPY {table_name}({cols_str})
+            f"""
+            COPY {dst_table_name}({cols_str})
             FROM STDIN
             DELIMITER ','
             CSV HEADER;
-            '''
+            """
         )
-        logger.debug(f'🔎 Query:\n{query}')
-        with open(os.path.expanduser(file_path), '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

@@ -1,9 +1,92 @@
-import queue
 import concurrent.futures
+import queue
+from typing import Callable
 
 from loguru import logger
 
 
+class StreamingQ:
+    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)
+
+    def execute(self):
+        """
+        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}")
+            except Exception as 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")
+
+        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":
+                    # 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}")
+                    yield result
+
+                except Exception as e:
+                    self.q.task_done()
+                    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:
+                # Cancel producer if consumer fails
+                future_producer.cancel()
+                raise
+
+
 class ThreadingQ:
     def __init__(self) -> None:
         self.q = queue.Queue()
@@ -23,8 +106,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 = []
@@ -32,7 +121,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
@@ -49,7 +138,7 @@ class ThreadingQ:
                 results.append(result)
 
                 self.q.task_done()
-                logger.debug(f'🔥 Consumed {item}')
+                logger.debug(f"🔥 Consumed {item}")
 
             return results
 
@@ -59,8 +148,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,8 @@ 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 +13,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 +38,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

@@ -1,21 +1,24 @@
-import duckdb
 import multiprocessing
 
+import duckdb
 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')"
+    )

utill/templates/mb.json

@@ -1,4 +1,5 @@
 {
   "base_url": "xxx",
-  "api_key": "xxx"
+  "api_key": "xxx",
+  "end": true
 }

utill/templates/pg.json

@@ -9,5 +9,6 @@
     "db": "xxx",
     "username": "xxx",
     "password": "xxx"
-  }
+  },
+  "end": true
 }

rdxz2_utill-0.0.3.dist-info/RECORD

@@ -1,34 +0,0 @@
-rdxz2_utill-0.0.3.dist-info/licenses/LICENSE,sha256=PF9CUvzP8XFYopEAzrMzSCovF7RdBdscPqJCDC6KjPc,1073
-utill/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-utill/my_bq.py,sha256=ZsjRbrbczGQ70CavXfyeAPaWT1OW5LyRFBxyusNZ0cc,14701
-utill/my_const.py,sha256=88dOqn6NPQ5-hfRqdkew5POoAIyO91XXOGvN76oNsdo,251
-utill/my_csv.py,sha256=76Q7IM7T_WYF5SybObN_MbkPqycirX4FnLd0DX3Kdyg,2742
-utill/my_datetime.py,sha256=KEZTplLk3tgVqqC3wClXFcsF_zo40fma_rtPg4kSJHc,2125
-utill/my_dict.py,sha256=jPaPfdn4WYpm0uIBPiYFinpHhx1jXpFVDJ9npmvxGZQ,391
-utill/my_encryption.py,sha256=SCF7PPur39cW4RHidsRhw-9BZP-ymUH-6LZ9nAHJDsY,2105
-utill/my_env.py,sha256=mREys72Ybg2p9p2s7ApOt0s_6F5-qxR8FyYEcSJ8pmU,2093
-utill/my_file.py,sha256=H3QmIOwubQCUMoOuk7jwf6AnqsljWZIuM7OjelyZby4,1865
-utill/my_gcs.py,sha256=VY2CXQbzBUhX-HunvAZ_y4E19eiuZ1b3TF33bUkJfp4,3953
-utill/my_input.py,sha256=OyKLoutXpwISReltuL_Gw2oojv16tYWJqQpqabBOQx4,350
-utill/my_json.py,sha256=WgW6mavGhfs4h1N5XbhsDnRk2dbh_ttJWdJUj4iWDN4,1473
-utill/my_mb.py,sha256=3_A5kXHgnkxGbd38vK5t5MfFcj84lohjS7C2OtlSo30,14841
-utill/my_pg.py,sha256=udsqNok7dOFz1rO-hQhqnEj8PpH9oMdkyyjGAdLRS-w,6554
-utill/my_queue.py,sha256=hINP4_yjmboSjHgo1J3CtPm2X9SE3HfczyED3ip7nfk,1930
-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=hNdkApzRhPloRSe4RyxbWuLoyeqkK7Yx9g44kcvKOEM,1800
-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=BPnVhMG2FgcxnThYp04Vn5zSQI0G-yQv99qTPNvmSok,44
-utill/templates/pg.json,sha256=49c8AoGznP-omKGEgWlIWFpj7qIjeOC5Nf5k0DxlbHE,256
-rdxz2_utill-0.0.3.dist-info/METADATA,sha256=WA0g56M8_ps8WcPoISrxCE-pG8PLURq3hPez2Pmc9qs,4489
-rdxz2_utill-0.0.3.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-rdxz2_utill-0.0.3.dist-info/entry_points.txt,sha256=9n5NWz5Wi9jDvYhB_81_4icgT5xABZ-QivHD8ibcafg,47
-rdxz2_utill-0.0.3.dist-info/top_level.txt,sha256=tuAYZoCsr02JYbpZj7I6fl1IIo53v3GG0uoj-_fINVk,6
-rdxz2_utill-0.0.3.dist-info/RECORD,,