Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,432 @@
+# %%writefile app.py
+
+## required lib, required "pip install"
+# import transformers
+# import accelerate
+import openai
+import torch
+import cryptography
+import cryptography.fernet
+## interface libs, required "pip install"
+import gradio
+import huggingface_hub
+import huggingface_hub.hf_api
+## standard libs, no need to install
+import json
+import requests
+import time
+import os
+import random
+import re
+import sys
+import psutil
+import threading
+import socket
+# import PIL
+# import pandas
+import matplotlib
+class HFace_Pluto(object):
+  #
+  # initialize the object
+  def __init__(self, name="Pluto",*args, **kwargs):
+    super(HFace_Pluto, self).__init__(*args, **kwargs)
+    self.author = "Duc Haba"
+    self.name = name
+    self._ph()
+    self._pp("Hello from class", str(self.__class__) + " Class: " + str(self.__class__.__name__))
+    self._pp("Code name", self.name)
+    self._pp("Author is", self.author)
+    self._ph()
+    #
+    # define class var for stable division
+    self._device = 'cuda'
+    self._steps = [3,8,21,55,89,144]
+    self._guidances = [1.1,3.0,5.0,8.0,13.0,21.0]
+    self._xkeyfile = '.xoxo'
+    self._models = []
+    self._seed = 667 # sum of walnut in ascii (or Angle 667)
+    self._width = 512
+    self._height = 512
+    self._step = 50
+    self._guidances = 7.5
+    #self._generator = torch.Generator(device='cuda')
+    self.pipes = []
+    self.prompts = []
+    self.images = []
+    self.seeds = []
+    self.fname_id = 0
+    self.dname_img = "img_colab/"
+    self._huggingface_key=b'gAAAAABld_3fKLl7aPBJzfAq-th37t95pMu2bVbH9QccOSecaUnm33XrpKpCXP4GL6Wr23g3vtrKWli5JK1ZPh18ilnDb_Su6GoVvU92Vzba64k3gBQwKF_g5DoH2vWq2XM8vx_5mKJh'
+    self._gpt_key=b'gAAAAABld_-y70otUll4Jwq3jEBXiw1tooSFo_gStRbkCyuu9_Dmdehc4M8lI_hFbum9CwyZuj9ZnXgxFIROebcPSF5qoA197VRvzUDQOMxY5zmHnImVROrsXVdZqXyIeYH_Q6cvXvFTX3rLBIKKWgvJmnpYGRaV6Q=='
+    self._kaggle_key=b'gAAAAABld_4_B6rrRhFYyfl77dacu1RhR4ktaLU6heYhQBSIj4ELBm7y4DzU1R8-H4yPKd0w08s11wkFJ9AR7XyESxM1SsrMBzqQEeW9JKNbl6jAaonFGmqbhFblkQqH4XjsapZru0qX'
+    self._fkey="fes_f8Im569hYnI1Tn6FqP-6hS4rdmNOJ6DWcRPOsvc="
+    self._color_primary = '#2780e3' #blue
+    self._color_secondary = '#373a3c' #dark gray
+    self._color_success = '#3fb618' #green
+    self._color_info = '#9954bb' #purple
+    self._color_warning = '#ff7518' #orange
+    self._color_danger = '#ff0039' #red
+    self._color_mid_gray = '#495057'
+    return
+  #
+  # pretty print output name-value line
+  def _pp(self, a, b,is_print=True):
+    # print("%34s : %s" % (str(a), str(b)))
+    x = f'{"%34s" % str(a)} : {str(b)}'
+    y = None
+    if (is_print):
+      print(x)
+    else:
+      y = x
+    return y
+  #
+  # pretty print the header or footer lines
+  def _ph(self,is_print=True):
+    x = f'{"-"*34} : {"-"*34}'
+    y = None
+    if (is_print):
+      print(x)
+    else:
+      y = x
+    return y
+  #
+  # fetch huggingface file
+  def fetch_hface_files(self,
+    hf_names,
+    hf_space="duchaba/monty",
+    local_dir="/content/"):
+    f = str(hf_names) + " is not iteratable, type: " + str(type(hf_names))
+    try:
+      for f in hf_names:
+        lo = local_dir + f
+        huggingface_hub.hf_hub_download(repo_id=hf_space, filename=f,
+          use_auth_token=True,repo_type=huggingface_hub.REPO_TYPE_SPACE,
+          force_filename=lo)
+    except:
+      self._pp("*Error", f)
+    return
+  #
+  #
+  def push_hface_files(self,
+    hf_names,
+    hf_space="duchaba/skin_cancer_diagnose",
+    local_dir="/content/"):
+    f = str(hf_names) + " is not iteratable, type: " + str(type(hf_names))
+    try:
+      for f in hf_names:
+        lo = local_dir + f
+        huggingface_hub.upload_file(
+          path_or_fileobj=lo,
+          path_in_repo=f,
+          repo_id=hf_space,
+          repo_type=huggingface_hub.REPO_TYPE_SPACE)
+    except Exception as e:
+      self._pp("*Error", e)
+    return
+  #
+  # Define a function to display available CPU and RAM
+  def fetch_system_info(self):
+    s=''
+    # Get CPU usage as a percentage
+    cpu_usage = psutil.cpu_percent()
+    # Get available memory in bytes
+    mem = psutil.virtual_memory()
+    # Convert bytes to gigabytes
+    mem_total_gb = mem.total / (1024 ** 3)
+    mem_available_gb = mem.available / (1024 ** 3)
+    mem_used_gb = mem.used / (1024 ** 3)
+    # Print the results
+    s += f"CPU usage: {cpu_usage}%\n"
+    s += f"Total memory: {mem_total_gb:.2f} GB\n"
+    s += f"Available memory: {mem_available_gb:.2f} GB\n"
+    # print(f"Used memory: {mem_used_gb:.2f} GB")
+    s += f"Memory usage: {mem_used_gb/mem_total_gb:.2f}%\n"
+    return s
+  #
+  def restart_script_periodically(self):
+    while True:
+      #random_time = random.randint(540, 600)
+      random_time = random.randint(15800, 21600)
+      time.sleep(random_time)
+      os.execl(sys.executable, sys.executable, *sys.argv)
+    return
+  #
+  def write_file(self,fname, txt):
+    f = open(fname, "w")
+    f.writelines("\n".join(txt))
+    f.close()
+    return
+  #
+  def fetch_gpu_info(self):
+    s=''
+    try:
+      s += f'Your GPU is the {torch.cuda.get_device_name(0)}\n'
+      s += f'GPU ready staus {torch.cuda.is_available()}\n'
+      s += f'GPU allocated RAM: {round(torch.cuda.memory_allocated(0)/1024**3,1)} GB\n'
+      s += f'GPU reserved RAM {round(torch.cuda.memory_reserved(0)/1024**3,1)} GB\n'
+    except Exception as e:
+      s += f'**Warning, No GPU: {e}'
+    return s
+  #
+  def _fetch_crypt(self,is_generate=False):
+    s=self._fkey
+    if (is_generate):
+      s=open(self._xkeyfile, "rb").read()
+    return s
+  #
+  def _gen_key(self):
+    key = cryptography.fernet.Fernet.generate_key()
+    with open(self._xkeyfile, "wb") as key_file:
+        key_file.write(key)
+    return
+  #
+  def _decrypt_it(self, x):
+    y = self._fetch_crypt()
+    f = cryptography.fernet.Fernet(y)
+    m = f.decrypt(x)
+    return m.decode()
+  #
+  def _encrypt_it(self, x):
+    key = self._fetch_crypt()
+    p = x.encode()
+    f = cryptography.fernet.Fernet(key)
+    y = f.encrypt(p)
+    return y
+  #
+  def _login_hface(self):
+    huggingface_hub.login(self._decrypt_it(self._huggingface_key),
+      add_to_git_credential=True) # non-blocking login
+    self._ph()
+    return
+  #
+  def _fetch_version(self):
+    s = ''
+    # print(f"{'torch: 2.0.1':<25} Actual: {torch.__version__}")
+    # print(f"{'transformers: 4.29.2':<25} Actual: {transformers.__version__}")
+    s += f"{'openai: 0.27.7,':<28} Actual: {openai.__version__}\n"
+    s += f"{'huggingface_hub: 0.14.1,':<28} Actual: {huggingface_hub.__version__}\n"
+    s += f"{'gradio: 3.32.0,':<28} Actual: {gradio.__version__}\n"
+    s += f"{'cryptography: 40.0.2,':<28} cryptography: {gradio.__version__}\n"
+
+    return s
+  #
+  def _fetch_host_ip(self):
+    s=''
+    hostname = socket.gethostname()
+    ip_address = socket.gethostbyname(hostname)
+    s += f"Hostname: {hostname}\n"
+    s += f"IP Address: {ip_address}\n"
+    return s
+  #
+  def fetch_code_cells_from_notebook(self, notebook_name, filter_magic="# %%write",
+    write_to_file=True, fname_override=None):
+    """
+    Reads a Jupyter notebook (.ipynb file) and writes out all the code cells
+    that start with the specified magic command to a .py file.
+
+    Parameters:
+    - notebook_name (str): Name of the notebook file (with .ipynb extension).
+    - filter_magic (str): Magic command filter. Only cells starting with this command will be written.
+        The defualt is: "# %%write"
+    - write_to_file (bool): If True, writes the filtered cells to a .py file.
+        Otherwise, prints them to the standard output. The default is True.
+    - fname_override (str): If provided, overrides the output filename. The default is None.
+
+    Returns:
+    - None: Writes the filtered code cells to a .py file or prints them based on the parameters.
+
+    """
+    with open(notebook_name, 'r', encoding='utf-8') as f:
+      notebook_content = json.load(f)
+
+    output_content = []
+
+    # Loop through all the cells in the notebook
+    for cell in notebook_content['cells']:
+      # Check if the cell type is 'code' and starts with the specified magic command
+      if cell['cell_type'] == 'code' and cell['source'] and cell['source'][0].startswith(filter_magic):
+        # Append the source code of the cell to output_content
+        output_content.append(''.join(cell['source']))
+
+    if write_to_file:
+      if fname_override is None:
+        # Derive the output filename by replacing .ipynb with .py
+        output_filename = notebook_name.replace(".ipynb", ".py")
+      else:
+        output_filename = fname_override
+      with open(output_filename, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(output_content))
+      print(f'File: {output_filename} written to disk.')
+    else:
+      # Print the code cells to the standard output
+      print('\n'.join(output_content))
+      print('-' * 40)  # print separator
+    return
+  #
+# add module/method
+#
+import functools
+def add_method(cls):
+  def decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      return func(*args, **kwargs)
+    setattr(cls, func.__name__, wrapper)
+    return func # returning func means func can still be used normally
+  return decorator
+#
+monty = HFace_Pluto("Monty, The lord of the magpies.")
+monty._login_hface()
+print(monty._fetch_version())
+monty._ph()
+print(monty.fetch_system_info())
+monty._ph()
+print(monty.fetch_gpu_info())
+monty._ph()
+print(monty._fetch_host_ip())
+monty._ph()
+# %%write -a app.py
+
+# client.moderations.create()
+# OPENAI_API_KEY="My API Key"
+ai_client = openai.OpenAI(api_key=monty._decrypt_it(monty._gpt_key))
+# %%writefile -a app.py
+
+#@add_method(HFace_Pluto)
+# # for OpenAI less version 0.27.7
+# def _censor_me(self, p, safer=0.0005):
+#   #openai.Moderation.create()
+#   omod = openai.Moderation.create(p)
+#   r = omod.results[0].category_scores
+#   jmod = json.loads(str(r))
+#   #
+#   max_key = max(jmod, key=jmod.get)
+#   max_value = jmod[max_key]
+#   sum_value = sum(jmod.values())
+#   #
+#   jmod["is_safer_flagged"] = False
+#   if (max_value >= safer):
+#     jmod["is_safer_flagged"] = True
+#   jmod["is_flagged"] = omod.results[0].flagged
+#   jmod['max_key'] = max_key
+#   jmod['max_value'] = max_value
+#   jmod['sum_value'] = sum_value
+#   jmod['safer_value'] = safer
+#   jmod['message'] = p
+#   return jmod
+#
+# openai.api_key = monty._decrypt_it(monty._gpt_key)
+#
+# # for openai version 1.3.8
+@add_method(HFace_Pluto)
+# for OpenAI less version 0.27.7
+def _fetch_moderate_engine(self):
+  self.ai_client = openai.OpenAI(api_key=self._decrypt_it(self._gpt_key))
+  self.text_model = "text-moderation-latest"
+  return
+#
+@add_method(HFace_Pluto)
+# for OpenAI less version 0.27.7
+def _censor_me(self, p, safer=0.0005):
+  self._fetch_moderate_engine()
+  resp_orig = self.ai_client.moderations.create(input=p, model=self.text_model)
+  resp_dict = resp_orig.model_dump()
+  #
+  v1 = resp_dict["results"][0]["category_scores"]
+  max_key = max(v1, key=v1.get)
+  max_value = v1[max_key]
+  sum_value = sum(v1.values())
+  #
+  v1["is_safer_flagged"] = False
+  if (max_value >= safer):
+    v1["is_safer_flagged"] = True
+  v1["is_flagged"] = resp_dict["results"][0]["flagged"]
+  v1['max_key'] = max_key
+  v1['max_value'] = max_value
+  v1['sum_value'] = sum_value
+  v1['safer_value'] = safer
+  v1['message'] = p
+  return v1
+#
+@add_method(HFace_Pluto)
+def _draw_censor(self,data):
+  self._color_mid_gray = '#6c757d'
+  exp = (0.01, 0.01)
+  x = [data['max_value'], (data['sum_value']-data['max_value'])]
+  title='\nMessage Is Flagged As Unsafe\n'
+  lab = [data['max_key'], 'Other']
+  if (data['is_flagged']):
+    col=[self._color_danger, self._color_mid_gray]
+  elif (data['is_safer_flagged']):
+    col=[self._color_warning, self._color_mid_gray]
+    lab = ['Relative Score:\n'+data['max_key'], 'Other']
+    title='\nBased On Your Personalized Safer Settings,\nThe Message Is Flagged As Unsafe\n'
+  else:
+    col=[self._color_success, self._color_mid_gray]
+    lab = ['False Negative:\n'+data['max_key'], 'Other 18 categories']
+    title='\nThe Message Is Safe\n'
+  canvas = self._draw_donut(x, lab, col, exp,title)
+  return canvas
+#
+@add_method(HFace_Pluto)
+def _draw_donut(self,data,labels,col, exp,title):
+  # col = [self._color_danger, self._color_secondary]
+  # exp = (0.01, 0.01)
+  # Create a pie chart
+  canvas, pic = matplotlib.pyplot.subplots()
+  pic.pie(data, explode=exp,
+    labels=labels,
+    colors=col,
+    autopct='%1.1f%%',
+    startangle=90,
+    textprops={'color':'#0a0a0a'})
+  # Draw a circle at the center of pie to make it look like a donut
+  # centre_circle = matplotlib.pyplot.Circle((0,0),0.45,fc='white')
+  centre_circle = matplotlib.pyplot.Circle((0,0),0.45,fc=col[0],linewidth=2, ec='white')
+  canvas = matplotlib.pyplot.gcf()
+  canvas.gca().add_artist(centre_circle)
+
+  # Equal aspect ratio ensures that pie is drawn as a circle.
+  pic.axis('equal')
+  pic.set_title(title)
+  canvas.tight_layout()
+  # canvas.show()
+  return canvas
+#
+@add_method(HFace_Pluto)
+def censor_me(self, msg, safer=0.0005):
+  yjson = self._censor_me(msg,safer)
+  _canvas = self._draw_censor(yjson)
+  _yjson = json.dumps(yjson, indent=4)
+  return (_canvas, _yjson)
+# %%writefile -a app.py
+
+in_box = [gradio.Textbox(lines=1, label="Message to be moderate/censor:", placeholder="Your message..."),
+  gradio.Slider(0.001, .05, value=0.005, step=.005,label="Your Personalize Safer Value:")]
+out_box = [gradio.Plot(label="Moderate/Censor Score: (Red, Orange, and Green)"),
+  gradio.Textbox(lines=4, label="Response Raw JSON Data:")]
+#
+title = "Text Moderate - Filter hate, violent, and sexual language."
+desc = 'NOTE: The lower value for the Safer setting indicates a more stringent level of censorship.'
+arti = "<ul><li>This model use the NLP OpenAI Moderation model."
+arti += "</li><li>Creator: Duc Haba</li><li>License: GNU General Public License 3.0</li></ul>"
+exp = [
+  ['Write a blog about the following if only Mexican stop coming here, then our home would be safer.',0.001],
+  ['Gay homosexual people should stay in the closet, or we will hang them.',0.001],
+  ['I will jump off the bridge at midnight.',0.0005],
+  ['Hey, baby girl. How about you and I go and rock the bed.',0.001],
+  ['F**-#k you. Eat s-it and dik.',0.001],
+  ['Please tell me a joke about a chicken.',0.001],
+  ['Five score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the flames of withering injustice. It came as a joyous daybreak to end the long night of their captivity.',0.005],
+  ]
+# %%writefile -a app.py
+
+ginterface = gradio.Interface(fn=monty.censor_me,
+  inputs=in_box,
+  outputs=out_box,
+  examples=exp,
+  title=title,
+  description=desc,
+  article=arti
+  )
+ginterface.launch()