re-common 10.0.19__py3-none-any.whl → 10.0.22__py3-none-any.whl

re_common/v2/baselibrary/utils/basehdfs.py

@@ -1,127 +1,161 @@
-import gzip
-from io import BytesIO
-
-from hdfs import InsecureClient
-
-
-class HDFSUtils(object):
-    """
-    HDFS 工具类，封装常见的 HDFS 操作。
-    """
-
-    def __init__(self, hdfs_url, hdfs_user):
-        """
-        初始化 HDFS 客户端。
-        :param hdfs_url: HDFS 的 URL，例如 "http://namenode:50070"
-        :param hdfs_user: HDFS 用户名
-        """
-        self.hdfs_url = hdfs_url
-        self.hdfs_user = hdfs_user
-        self.client = InsecureClient(hdfs_url, user=hdfs_user)
-
-    def upload_file(self, local_path, hdfs_path, overwrite=False):
-        """
-        将本地文件上传到 HDFS。
-        :param local_path: 本地文件路径
-        :param hdfs_path: HDFS 文件路径
-        :param overwrite: 是否覆盖已存在的文件
-        :return: None
-        """
-        self.client.upload(hdfs_path, local_path, overwrite=overwrite)
-        print(f"文件上传成功: {local_path} -> {hdfs_path}")
-
-    def download_file(self, hdfs_path, local_path, overwrite=False):
-        """
-        从 HDFS 下载文件到本地。
-        :param hdfs_path: HDFS 文件路径
-        :param local_path: 本地文件路径
-        :param overwrite: 是否覆盖已存在的文件
-        :return: None
-        """
-        self.client.download(hdfs_path, local_path, overwrite=overwrite)
-        print(f"文件下载成功: {hdfs_path} -> {local_path}")
-
-    def delete_file(self, hdfs_path, recursive=False):
-        """
-        删除 HDFS 上的文件或目录。
-        :param hdfs_path: HDFS 文件或目录路径
-        :param recursive: 是否递归删除目录
-        :return: None
-        """
-        self.client.delete(hdfs_path, recursive=recursive)
-        print(f"文件/目录删除成功: {hdfs_path}")
-
-    def create_directory(self, hdfs_path):
-        """
-        在 HDFS 上创建目录。
-        :param hdfs_path: HDFS 目录路径
-        :return: None
-        """
-        self.client.makedirs(hdfs_path)
-        print(f"目录创建成功: {hdfs_path}")
-
-    def list_files(self, hdfs_path):
-        """
-        列出 HDFS 目录下的文件和子目录。
-        :param hdfs_path: HDFS 目录路径
-        :return: 文件/目录列表
-        """
-        files = self.client.list(hdfs_path)
-        return files
-
-    def read_file(self, hdfs_path):
-        """
-        读取 HDFS 文件内容。
-        :param hdfs_path: HDFS 文件路径
-        :return: 文件内容
-        """
-        with self.client.read(hdfs_path) as reader:
-            content = reader.read()
-            print(f"文件读取成功: {hdfs_path}")
-            return content
-
-    def read_gz_file(self, hdfs_path, encoding='utf-8'):
-        """
-        读取 HDFS 上的 .gz 文件内容。
-        :param hdfs_path: HDFS 文件路径（必须以 .gz 结尾）
-        :param encoding: 文件编码格式（默认 utf-8）
-        :return: 文件内容
-        """
-        with self.client.read(hdfs_path) as reader:  # 以二进制模式读取
-            compressed_data = reader.read()  # 读取压缩数据
-            with gzip.GzipFile(fileobj=BytesIO(compressed_data)) as gz_file:  # 解压缩
-                content = gz_file.read().decode(encoding)  # 解码为字符串
-                print(f"文件读取成功: {hdfs_path}")
-                return content
-
-    def write_file(self, hdfs_path, content, overwrite=False, encoding='utf-8'):
-        """
-        向 HDFS 文件写入内容。
-        :param hdfs_path: HDFS 文件路径
-        :param content: 要写入的内容
-        :param overwrite: 是否覆盖已存在的文件
-        :param encoding: 文件编码格式
-        :return: None
-        """
-        with self.client.write(hdfs_path, overwrite=overwrite, encoding=encoding) as writer:
-            writer.write(content)
-            print(f"文件写入成功: {hdfs_path}")
-
-    def file_exists(self, hdfs_path):
-        """
-        检查 HDFS 文件或目录是否存在。
-        :param hdfs_path: HDFS 文件或目录路径
-        :return: 是否存在
-        """
-        status = self.client.status(hdfs_path, strict=False)
-        return status is not None
-
-    def rename_file(self, hdfs_src_path, hdfs_dst_path):
-        """
-        重命名或移动 HDFS 文件/目录。
-        :param hdfs_src_path: 源路径
-        :param hdfs_dst_path: 目标路径
-        :return: None
-        """
-        self.client.rename(hdfs_src_path, hdfs_dst_path)
-        print(f"文件/目录重命名成功: {hdfs_src_path} -> {hdfs_dst_path}")
+import gzip
+from io import BytesIO
+
+from hdfs import InsecureClient
+
+
+class HDFSUtils(object):
+    """
+    HDFS 工具类，封装常见的 HDFS 操作。
+    """
+
+    def __init__(self, hdfs_url, hdfs_user):
+        """
+        初始化 HDFS 客户端。
+        :param hdfs_url: HDFS 的 URL，例如 "http://namenode:50070"
+        :param hdfs_user: HDFS 用户名
+        """
+        self.hdfs_url = hdfs_url
+        self.hdfs_user = hdfs_user
+        self.client = InsecureClient(hdfs_url, user=hdfs_user)
+
+    def upload_file(self, local_path, hdfs_path, overwrite=False):
+        """
+        将本地文件上传到 HDFS。
+        :param local_path: 本地文件路径
+        :param hdfs_path: HDFS 文件路径
+        :param overwrite: 是否覆盖已存在的文件
+        :return: None
+        """
+        self.client.upload(hdfs_path, local_path, overwrite=overwrite)
+        print(f"文件上传成功: {local_path} -> {hdfs_path}")
+
+    def download_file(self, hdfs_path, local_path, overwrite=False):
+        """
+        从 HDFS 下载文件到本地。
+        :param hdfs_path: HDFS 文件路径
+        :param local_path: 本地文件路径
+        :param overwrite: 是否覆盖已存在的文件
+        :return: None
+        """
+        self.client.download(hdfs_path, local_path, overwrite=overwrite)
+        print(f"文件下载成功: {hdfs_path} -> {local_path}")
+
+    def delete_file(self, hdfs_path, recursive=False):
+        """
+        删除 HDFS 上的文件或目录。
+        :param hdfs_path: HDFS 文件或目录路径
+        :param recursive: 是否递归删除目录
+        :return: None
+        """
+        self.client.delete(hdfs_path, recursive=recursive)
+        print(f"文件/目录删除成功: {hdfs_path}")
+
+    def create_directory(self, hdfs_path):
+        """
+        在 HDFS 上创建目录。
+        :param hdfs_path: HDFS 目录路径
+        :return: None
+        """
+        self.client.makedirs(hdfs_path)
+        print(f"目录创建成功: {hdfs_path}")
+
+    def list_files(self, hdfs_path):
+        """
+        列出 HDFS 目录下的文件和子目录。
+        :param hdfs_path: HDFS 目录路径
+        :return: 文件/目录列表
+        """
+        files = self.client.list(hdfs_path)
+        return files
+
+    def read_file(self, hdfs_path):
+        """
+        读取 HDFS 文件内容。
+        :param hdfs_path: HDFS 文件路径
+        :return: 文件内容
+        """
+        with self.client.read(hdfs_path) as reader:
+            content = reader.read()
+            print(f"文件读取成功: {hdfs_path}")
+            return content
+
+    def read_gz_file(self, hdfs_path, encoding='utf-8'):
+        """
+        读取 HDFS 上的 .gz 文件内容。
+        :param hdfs_path: HDFS 文件路径（必须以 .gz 结尾）
+        :param encoding: 文件编码格式（默认 utf-8）
+        :return: 文件内容
+        """
+        with self.client.read(hdfs_path) as reader:  # 以二进制模式读取
+            compressed_data = reader.read()  # 读取压缩数据
+            with gzip.GzipFile(fileobj=BytesIO(compressed_data)) as gz_file:  # 解压缩
+                content = gz_file.read().decode(encoding)  # 解码为字符串
+                print(f"文件读取成功: {hdfs_path}")
+                return content
+
+    def write_file(self, hdfs_path, content, overwrite=False, encoding='utf-8'):
+        """
+        向 HDFS 文件写入内容。
+        :param hdfs_path: HDFS 文件路径
+        :param content: 要写入的内容
+        :param overwrite: 是否覆盖已存在的文件
+        :param encoding: 文件编码格式
+        :return: None
+        """
+        with self.client.write(hdfs_path, overwrite=overwrite, encoding=encoding) as writer:
+            writer.write(content)
+            print(f"文件写入成功: {hdfs_path}")
+
+    def write_file_kwargs(self, hdfs_path, content, **kwargs):
+        """
+        向 HDFS 文件写入内容
+        自定义参数实现更大的灵活性
+        """
+        with self.client.write(hdfs_path, **kwargs) as writer:
+            writer.write(content)
+            print(f"文件写入成功: {hdfs_path}")
+
+    def safe_append_hdfs(self, hdfs_path, content):
+        """
+        更安全的追加写入方式，显式检查文件是否存在
+
+        :param content: 要写入的内容
+        :param hdfs_path: HDFS文件路径
+        """
+        try:
+            # 检查文件是否存在
+            file_exists = self.client.status(hdfs_path, strict=False) is not None
+
+            if not file_exists:
+                print(f"文件 {hdfs_path} 不存在，将创建新文件")
+                # 第一次写入不使用append模式
+                with self.client.write(hdfs_path, encoding='utf-8') as writer:
+                    writer.write(content)
+            else:
+                # 追加模式写入
+                with self.client.write(hdfs_path, encoding='utf-8', append=True) as writer:
+                    writer.write(content)
+
+        except Exception as e:
+            print(f"文件操作失败: {str(e)}")
+            raise
+
+    def file_exists(self, hdfs_path):
+        """
+        检查 HDFS 文件或目录是否存在。
+        :param hdfs_path: HDFS 文件或目录路径
+        :return: 是否存在
+        """
+        status = self.client.status(hdfs_path, strict=False)
+        return status is not None
+
+    def rename_file(self, hdfs_src_path, hdfs_dst_path):
+        """
+        重命名或移动 HDFS 文件/目录。
+        :param hdfs_src_path: 源路径
+        :param hdfs_dst_path: 目标路径
+        :return: None
+        """
+        self.client.rename(hdfs_src_path, hdfs_dst_path)
+        print(f"文件/目录重命名成功: {hdfs_src_path} -> {hdfs_dst_path}")

re_common/v2/baselibrary/utils/basepika.py

@@ -1,180 +1,180 @@
-import pika
-
-
-# https://blog.csdn.net/songfreeman/article/details/50943603
-class BasePika(object):
-
-    def __init__(self, username=None, password=None, mqhost=None, virtual_host=None):
-        self.username = username
-        self.password = password
-        self.conn = None
-        self.host = mqhost
-        self.virtual_host = virtual_host
-        self.auto_ack = True
-
-    def set_default(self):
-        self.host = "192.168.31.79"
-        self.virtual_host = "vhost_NetDataGather"
-        self.username = "vip"
-        self.password = "piv$*123"
-
-    def connect_str(self,amqp_str):
-        parameters = pika.URLParameters(amqp_str)
-        self.conn = pika.BlockingConnection(parameters)
-
-    def connect(self):
-        """
-        设置用户名 密码 进行连接
-        :return:
-        """
-        credentials = pika.PlainCredentials(self.username, self.password)
-        # parameters = pika.URLParameters('amqp://guest:guest@rabbit-server1:5672/%2F')
-        # 可以通过将 heartbeat 设为 0，关闭 rabbitmq 的心跳检测
-        parameters = pika.ConnectionParameters(host=self.host,
-                                               virtual_host=self.virtual_host,
-                                               credentials=credentials,
-                                               heartbeat=0)
-        self.conn = pika.BlockingConnection(parameters)
-
-    def close(self):
-        # 关闭消息队列
-        self.conn.close()
-
-    def create_channel(self):
-        self.channel = self.conn.channel()
-
-    def __del__(self):
-        self.channel.close()
-        self.conn.close()
-
-    def random_queue_declare(self):
-        """
-        这样, result.method.queue 包含一个随机的队列名, 比如：看起来像 amq.gen-JzTY20BRgKO-HjmUJj0wLg.
-        其次：
-        一旦我们断开consumer连接，这个队列名将自动删除。这里有一个标识设置：
-        :return:
-        """
-        return self.channel.queue_declare("", exclusive=True)
-
-    def queue_declare(self, queue="hello", durable=False):
-        """
-        创建目的地队列hello 取消息时也可以调用
-        取消息和发送消息都调用 保证队列存在，也保证了不管服务端还是客户端先启动都有队列
-        durable True 为持久化
-        :return:
-        """
-        return self.channel.queue_declare(queue=queue, durable=durable)
-
-    def get_queue_size(self, queue="hello"):
-        """
-        获取某个队列的长度
-        :param queue:
-        :return:
-        """
-        queue = self.queue_declare(queue=queue, durable=True)
-        return queue.method.message_count
-
-    def get_properties(self):
-        """
-        与 queue_declare里的 durable = True 配合使用，
-        设置给 easy_send_msg的properties
-        :return:
-        """
-        return pika.BasicProperties(
-            delivery_mode=2,  # 设置消息为持久化的
-        )
-
-    def easy_send_msg(self, exchange="", routing_key="hello", body="hello world", properties=None):
-        """
-        空字符串标识默认的或者匿名的exchange,如果存在routing_key, 消息路由到routing_key指定的队列中。
-        routing_key 标识发送到哪个队列,就是服务器上的队列名
-        body 发送的消息
-
-        basic_publish 如果 exchange 不是"" 但没有绑定队列 消息会消失
-        :return:
-        """
-        self.channel.basic_publish(exchange=exchange,
-                                   routing_key=routing_key,
-                                   body=body,
-                                   properties=properties)
-
-    def basic_ack(self, ch, method):
-        """
-        callback的消息确认
-        :param ch:
-        :param method:
-        :return:
-        """
-        ch.basic_ack(delivery_tag=method.delivery_tag)
-
-    def callback(self, ch, method, properties, body):
-        """
-        从队列接收消息要更复杂一些，它需要为队列订阅一个 callback 函数来进行接收。
-        当我们接收一个消息后，这个 callback 函数将会被 pika函数库自动调用，
-        在我们的这个实例里面这个函数将用来打印接收的消息内容到屏幕
-        :param method:
-        :param properties:
-        :param body:
-        :return:
-        """
-        print(type(body))
-        print(" [x] Received %r" % body)
-        if self.auto_ack is False:
-            self.basic_ack(ch, method)
-
-    def set_get_msg_callback(self, routing_key="hello", callback=None, auto_ack=True):
-        """
-        设置取消息的callback
-        no_ack 如果设置为True，将使用自动确认模式
-        no_ack 如果设置为False，在callback中确认
-        :return:
-        """
-        self.auto_ack = auto_ack
-        if callback is None:
-            callback = self.callback
-        self.channel.basic_consume(routing_key,
-                                   callback,
-                                   auto_ack=auto_ack)
-
-    def start_get_msg(self):
-        """
-        开始取消息,会循环不停的取消息
-        :return:
-        """
-        self.channel.start_consuming()
-
-    def basic_qos(self, prefetch_count=1):
-        """
-        可以提前发送几个消息来，当auto_ack=True时无效
-        prefetch_count==1 消息未处理完前不要发送信息的消息
-        :return:
-        """
-        self.channel.basic_qos(prefetch_count=prefetch_count)
-
-    def exchange_declare(self, exchangename="logs", type="fanout"):
-        """
-        fanout exchange非常简单，你从这个名字中就能猜出来，它将从Producer方收到的消息广播给所有他知道的receiver方。而这正是我们的logger记录所需要的消息。
-        交换的类型
-        直接交换（direct exchange）的路由算法很简单 --  消息发送到绑定键值(binding key) 刚好完全符合路由键值( routing key) 的消息队列中。
-
-        消息发送到一个 topic交换不能是一个任意的 routing_key -- 它必须是一个用小数点 分割的单词列表。 这个字符可以是任何单词，但是通常是指定一些连接特定消息的功能。一些有效的路由键(routing key）比如：“stock.usd.nyse",
-        topic 是 直接交换的升级版
-
-        headers Exchange ：headers交换器允许你匹配AMQP消息的header而非路由键。除此之外，headers交换器和direct交换器完全一致，但性能会差很多。因此它并不太实用，而且几乎再也用不到了。
-        exchangename接下来会与队列绑定
-         direct  ,  topic ,  headers  和 fanout
-        :return:
-        """
-        return self.channel.exchange_declare(exchange=exchangename,
-                                             exchange_type=type)
-
-    def queue_bind(self, exchange="logs", queue="", routing_key=""):
-        """
-        queue 临时队列获取 self.random_queue_declare().method.queue
-        :param exchange:
-        :param queue:
-        :return:
-        """
-        self.channel.queue_bind(exchange=exchange,
-                                queue=queue,
-                                routing_key=routing_key)
+import pika
+
+
+# https://blog.csdn.net/songfreeman/article/details/50943603
+class BasePika(object):
+
+    def __init__(self, username=None, password=None, mqhost=None, virtual_host=None):
+        self.username = username
+        self.password = password
+        self.conn = None
+        self.host = mqhost
+        self.virtual_host = virtual_host
+        self.auto_ack = True
+
+    def set_default(self):
+        self.host = "192.168.31.79"
+        self.virtual_host = "vhost_NetDataGather"
+        self.username = "vip"
+        self.password = "piv$*123"
+
+    def connect_str(self,amqp_str):
+        parameters = pika.URLParameters(amqp_str)
+        self.conn = pika.BlockingConnection(parameters)
+
+    def connect(self):
+        """
+        设置用户名 密码 进行连接
+        :return:
+        """
+        credentials = pika.PlainCredentials(self.username, self.password)
+        # parameters = pika.URLParameters('amqp://guest:guest@rabbit-server1:5672/%2F')
+        # 可以通过将 heartbeat 设为 0，关闭 rabbitmq 的心跳检测
+        parameters = pika.ConnectionParameters(host=self.host,
+                                               virtual_host=self.virtual_host,
+                                               credentials=credentials,
+                                               heartbeat=0)
+        self.conn = pika.BlockingConnection(parameters)
+
+    def close(self):
+        # 关闭消息队列
+        self.conn.close()
+
+    def create_channel(self):
+        self.channel = self.conn.channel()
+
+    def __del__(self):
+        self.channel.close()
+        self.conn.close()
+
+    def random_queue_declare(self):
+        """
+        这样, result.method.queue 包含一个随机的队列名, 比如：看起来像 amq.gen-JzTY20BRgKO-HjmUJj0wLg.
+        其次：
+        一旦我们断开consumer连接，这个队列名将自动删除。这里有一个标识设置：
+        :return:
+        """
+        return self.channel.queue_declare("", exclusive=True)
+
+    def queue_declare(self, queue="hello", durable=False):
+        """
+        创建目的地队列hello 取消息时也可以调用
+        取消息和发送消息都调用 保证队列存在，也保证了不管服务端还是客户端先启动都有队列
+        durable True 为持久化
+        :return:
+        """
+        return self.channel.queue_declare(queue=queue, durable=durable)
+
+    def get_queue_size(self, queue="hello"):
+        """
+        获取某个队列的长度
+        :param queue:
+        :return:
+        """
+        queue = self.queue_declare(queue=queue, durable=True)
+        return queue.method.message_count
+
+    def get_properties(self):
+        """
+        与 queue_declare里的 durable = True 配合使用，
+        设置给 easy_send_msg的properties
+        :return:
+        """
+        return pika.BasicProperties(
+            delivery_mode=2,  # 设置消息为持久化的
+        )
+
+    def easy_send_msg(self, exchange="", routing_key="hello", body="hello world", properties=None):
+        """
+        空字符串标识默认的或者匿名的exchange,如果存在routing_key, 消息路由到routing_key指定的队列中。
+        routing_key 标识发送到哪个队列,就是服务器上的队列名
+        body 发送的消息
+
+        basic_publish 如果 exchange 不是"" 但没有绑定队列 消息会消失
+        :return:
+        """
+        self.channel.basic_publish(exchange=exchange,
+                                   routing_key=routing_key,
+                                   body=body,
+                                   properties=properties)
+
+    def basic_ack(self, ch, method):
+        """
+        callback的消息确认
+        :param ch:
+        :param method:
+        :return:
+        """
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+
+    def callback(self, ch, method, properties, body):
+        """
+        从队列接收消息要更复杂一些，它需要为队列订阅一个 callback 函数来进行接收。
+        当我们接收一个消息后，这个 callback 函数将会被 pika函数库自动调用，
+        在我们的这个实例里面这个函数将用来打印接收的消息内容到屏幕
+        :param method:
+        :param properties:
+        :param body:
+        :return:
+        """
+        print(type(body))
+        print(" [x] Received %r" % body)
+        if self.auto_ack is False:
+            self.basic_ack(ch, method)
+
+    def set_get_msg_callback(self, routing_key="hello", callback=None, auto_ack=True):
+        """
+        设置取消息的callback
+        no_ack 如果设置为True，将使用自动确认模式
+        no_ack 如果设置为False，在callback中确认
+        :return:
+        """
+        self.auto_ack = auto_ack
+        if callback is None:
+            callback = self.callback
+        self.channel.basic_consume(routing_key,
+                                   callback,
+                                   auto_ack=auto_ack)
+
+    def start_get_msg(self):
+        """
+        开始取消息,会循环不停的取消息
+        :return:
+        """
+        self.channel.start_consuming()
+
+    def basic_qos(self, prefetch_count=1):
+        """
+        可以提前发送几个消息来，当auto_ack=True时无效
+        prefetch_count==1 消息未处理完前不要发送信息的消息
+        :return:
+        """
+        self.channel.basic_qos(prefetch_count=prefetch_count)
+
+    def exchange_declare(self, exchangename="logs", type="fanout"):
+        """
+        fanout exchange非常简单，你从这个名字中就能猜出来，它将从Producer方收到的消息广播给所有他知道的receiver方。而这正是我们的logger记录所需要的消息。
+        交换的类型
+        直接交换（direct exchange）的路由算法很简单 --  消息发送到绑定键值(binding key) 刚好完全符合路由键值( routing key) 的消息队列中。
+
+        消息发送到一个 topic交换不能是一个任意的 routing_key -- 它必须是一个用小数点 分割的单词列表。 这个字符可以是任何单词，但是通常是指定一些连接特定消息的功能。一些有效的路由键(routing key）比如：“stock.usd.nyse",
+        topic 是 直接交换的升级版
+
+        headers Exchange ：headers交换器允许你匹配AMQP消息的header而非路由键。除此之外，headers交换器和direct交换器完全一致，但性能会差很多。因此它并不太实用，而且几乎再也用不到了。
+        exchangename接下来会与队列绑定
+         direct  ,  topic ,  headers  和 fanout
+        :return:
+        """
+        return self.channel.exchange_declare(exchange=exchangename,
+                                             exchange_type=type)
+
+    def queue_bind(self, exchange="logs", queue="", routing_key=""):
+        """
+        queue 临时队列获取 self.random_queue_declare().method.queue
+        :param exchange:
+        :param queue:
+        :return:
+        """
+        self.channel.queue_bind(exchange=exchange,
+                                queue=queue,
+                                routing_key=routing_key)