text: import os
  import sys
  
  if __name__=='__main__':
      SRC_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
      sys.path.append(SRC_ROOT)
  
  import requests
  from utils.msg_util import *
  from settings.base import GITHUB_LOGIN, GITHUB_PASSWORD_OR_PERSONAL_ACCESS_TOKEN, GITHUB_TARGET_USERNAME, GITHUB_TARGET_REPOSITORY
  import json
  from github_issues.label_map import LabelMap
  
  
  class LabelHelper:
      
      def __init__(self, label_map_filename=None):
          """The add label to issue seems broken in pygithub3, just use this for now"""
          self.auth = (GITHUB_LOGIN, GITHUB_PASSWORD_OR_PERSONAL_ACCESS_TOKEN)
          
          self.label_map_filename = label_map_filename
          self.label_map = None
          self.using_label_map = False
          self.load_map()
          
      def load_map(self):
          """
          If a label_map_filename is specified, load it up!
          """
          if self.label_map_filename is None:
              self.using_label_map = False    # a bit redundant
              return
          
          self.label_map = LabelMap(self.label_map_filename)
          self.using_label_map = True
          
          self.make_update_map_labels()
          
          
      def make_update_map_labels(self):
          """
          Go through the label make and make sure they all exist, with the appropriate colors
          """ 
          msgt('Match label map names/color to GitHub')   
          
          for label_info in self.label_map.get_label_info_objects():
              
              msg('\nCheck label: %s %s' % (label_info.github_label_name, label_info.github_label_color))
  
              #  (1) try to get label
              #
              msg('  (1) Try to retrieve label')            
              label_url = 'https://api.github.com/repos/%s/%s/labels/%s' % (GITHUB_TARGET_USERNAME, GITHUB_TARGET_REPOSITORY, label_info.github_label_name)
              req = requests.get(label_url, auth=self.auth)
              msg('url: %s' % label_url)
              msg('status: %s' % req.status_code)
              
              #  (2) Label exists
              if req.status_code == 200:
                  github_label_info = req.json()
                  msg('-- label exists\n %s' % github_label_info)
                  #print label_info
                  
                  # (2a) Color matches! -- all done
                  if github_label_info.get('color', 'nope') == label_info.github_label_color:
                      msg('-- color matches!')
                      continue
                    
                  # (2b) Color doesn't match -- update color
                  msg('  (2b) Try to update label color')
                  label_url = 'https://api.github.com/repos/%s/%s/labels/%s' % (GITHUB_TARGET_USERNAME, GITHUB_TARGET_REPOSITORY, label_info.github_label_name)
                  data = dict(name=label_info.github_label_name\
                              , color=label_info.github_label_color)
                  req = requests.patch(label_url, data=json.dumps(data), auth=self.auth)
                  if req.status_code == 200:
                      msg('  Color updated!')
                      msg(req.text)
                      continue
                  msgx('Color updated failed!')
              
              # (3) Create new label with color
              msg('  (3) Try to create label')
              label_url = 'https://api.github.com/repos/%s/%s/labels' % (GITHUB_TARGET_USERNAME, GITHUB_TARGET_REPOSITORY)
              data = dict(name=label_info.github_label_name\
                          , color=label_info.github_label_color)
              req = requests.post(label_url, data=json.dumps(data), auth=self.auth)
              msg(req.text)
              msg(req.status_code)
              if req.status_code in [ 200, 201]:
                  msg('Label created with color!')
                  continue
              else:
                  msgx('Create label with color failed!')
          
          
      def clear_labels(self, issue_id):
          msgt('Clear Labels for an Issue.  Issue: [%s]' % (issue_id))
          #DELETE /repos/:owner/:repo/issues/:number/labels
          label_url = 'https://api.github.com/repos/%s/%s/issues/%s/labels' % (GITHUB_TARGET_USERNAME, GITHUB_TARGET_REPOSITORY, issue_id)
          req = requests.delete(label_url, auth=self.auth)
          msg('labels deleted!') 
          
          
  
      def add_labels_to_issue(self, issue_id, labels=[]):
          msg('Add Labels to Issue.  Issue: [%s] Labels: [%s]' % (issue_id, labels))
  
          if not issue_id or not type(labels) in [list, tuple]:
              return
          
          if len(labels) == 0:
              return
      
          label_url = 'https://api.github.com/repos/%s/%s/issues/%s/labels' % (GITHUB_TARGET_USERNAME, GITHUB_TARGET_REPOSITORY, issue_id)
      
          #labels = json.dumps(['invalid', 'bug', 'enhancement', 'duplicate'])#['Bug', 'invalid'])
          labels_for_call = json.dumps(labels)
          msg('labels: %s' % labels_for_call)
          
          req = requests.post(label_url, auth=self.auth, data=labels_for_call) 
  
          msg('result: %s' % req.text)
      
      
      
      def get_label_from_id_name(self, label_info_dict, key_name=None, label_prefix='', non_formatted=False):
          """
          Expects a dict in one of 2 formats (where key_name is "status"):
              Format 1:
              "status": { "id": 1, "name": "New"  },
          
              Format 2:
              { "id":3, "name":"UX/UI Component"}
              
          """
          if not type(label_info_dict) is dict:
              return None
          
          # For Format 1 above
          if key_name is not None:
              label_info_dict = label_info_dict.get(key_name, None)
              if label_info_dict is None:
                  return None
          
          if 'id' in label_info_dict and 'name' in label_info_dict:
              if non_formatted:
                  return label_info_dict['name']
                  
              if label_prefix:
                  return '%s %s' % (label_prefix, label_info_dict['name'])
  
              return label_info_dict['name']
          
          return None
          
      
      def get_label_names_based_on_map(self, redmine_issue_dict):
          """
          We're using the label map, so before using a label, create it with the appropriate color.
          
          If the label doesn't appear in the map, then discard it
          """
          label_names = self.get_label_names(redmine_issue_dict, non_formatted=True)
          
          if len(label_names) == 0:
              return []
          
          mapped_label_names = []
  
          for name in label_names:
              github_label_name = self.label_map.get_github_label_from_redmine_name(name)
              print('name', name, 'github_label_name: ', github_label_name)
              if github_label_name:
                  mapped_label_names.append(github_label_name)
          #msgx('blah')
          return mapped_label_names
              
      def get_label_names_from_issue(self, redmine_issue_dict):
          if self.using_label_map is True:
              return self.get_label_names_based_on_map(redmine_issue_dict)
          
          return self.get_label_names(redmine_issue_dict)
      
      
      def get_label_names(self, redmine_issue_dict, non_formatted=False):
          """
          Read a redmine issue and a make a list of formatted label names for
           - status
           - tracker
           - priority
           - component
           - category
          :returns: list with formatted label names
          """
          if not type(redmine_issue_dict) is dict:
              return []
              
          label_names = []
          
          # Add status
          status_label_name = self.get_label_from_id_name(redmine_issue_dict, 'status', 'Status:', non_formatted)
          if status_label_name:
              label_names.append(status_label_name)
  
          # Add tracker
          tracker_label_name = self.get_label_from_id_name(redmine_issue_dict, 'tracker', 'Tracker:', non_formatted)
          if tracker_label_name:
              label_names.append(tracker_label_name)
  
          # Add priority
          priority_label_name = self.get_label_from_id_name(redmine_issue_dict, 'priority', 'Priority:', non_formatted)
          if priority_label_name:
              label_names.append(priority_label_name)
  
          # Add category
          category_label_name = self.get_label_from_id_name(redmine_issue_dict, 'category', 'Category:', non_formatted)
          if category_label_name:
              label_names.append(category_label_name)
  
          # Add component
          #   "custom_fields": [
          #        {
          #            "id": 1, 
          #            "value": "0", 
          #            "name": "Usability Testing"
          #        }
          #    ],        
          #
          custom_fields = redmine_issue_dict.get('custom_fields', None)
          if custom_fields and len(custom_fields) > 0:
              for cf_dict in custom_fields:
                  component_label_name = self.get_label_from_id_name(cf_dict, None, 'Component:', non_formatted)
                  if component_label_name:
                      label_names.append(component_label_name)
  
          return label_names
          
  if __name__=='__main__':
      from settings.base import LABEL_MAP_FILE
      LabelHelper(LABEL_MAP_FILE)     # load a new label color map
      
              
  """
  #labels_service = pygithub3.services.issues.Labels(**auth)
  #auth = dict(login=GITHUB_LOGIN, password=GITHUB_PASSWORD_OR_PERSONAL_ACCESS_TOKEN)
  
  #pygithub3.services.issues.Labels
  
  # works!
  label_info = dict(name='Week of World Cup', color="006699")
  #issues_service.create(label_info)#, user=USER, repo=REPO)
  
  #existing_label = labels_service.get('Bug')
  #label_names = ['Bug', ]
  labels = json.dumps(['invalid', 'bug', 'enhancement', 'duplicate'])#['Bug', 'invalid'])
  
  labels_service.add_to_issue(1, labels=labels)
  #*label_names)
  #labels_service.add_to_issue(1, labels=[('label1', 'ffcc00')], user=USER, repo=REPO)
  
  """            
      