Python get gender

def getGender(cls, firstName, lang='en'):
        if not cls.isInitialized:
            cls.init()

        firstName = firstName.lower()
        nameInfo = cls.collection.find_one({
            'firstName': firstName,
            'lang': lang
            })

        if not nameInfo and lang != 'en':
            return cls.getGender(firstName, 'en')
        elif not nameInfo:
            return None
        
        return {'name': firstName, 'gender': nameInfo['gender'], 'lang': lang} 

def getGender(self):
        """
        Returns the Gender of the patient.

        Parameters
        ----------
        None

        Examples
        --------
        >>> import pyedflib
        >>> f = pyedflib.data.test_generator()
        >>> f.getGender()==''
        True
        >>> f.close()

        """
        return self._convert_string(self.gender.rstrip()) 

def get_gender_it(word, raw_string=""):
    """
    In Italian to define the grammatical gender of a word is necessary
    analyze the article that precedes the word and not only the last
    letter of the word.

    TODO: check if useful
    """

    gender = None
    words = raw_string.split(' ')
    for idx, w in enumerate(words):
        if w == word and idx != 0:
            previous = words[idx - 1]
            gender = get_gender_it(previous)
            break

    if not gender:
        if word[-1] == 'a' or word[-1] == 'e':
            gender = 'f'
        if word[-1] == 'o' or word[-1] == 'n' \
                or word[-1] == 'l' or word[-1] == 'i':
            gender = 'm'

    return gender 

def get_gender_es(word, raw_string=""):
    # Next rules are imprecise and incompleted, but is a good starting point.
    # For more detailed explanation, see
    # http://www.wikilengua.org/index.php/Género_gramatical
    word = word.rstrip("s")
    gender = False
    words = raw_string.split(" ")
    for idx, w in enumerate(words):
        if w == word and idx != 0:
            previous = words[idx - 1]
            gender = get_gender_es(previous)
            break
    if not gender:
        if word[-1] == "a":
            gender = "f"
        if word[-1] == "o" or word[-1] == "e":
            gender = "m"
    return gender 

def get_gender_name():
    try:
        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko'}
        boy_url = 'http://www.babynames.net/boy?page='
        girl_url = 'http://www.babynames.net/girl?page='
        boys_name = set()
        girls_name = set()
        for i in range(1, 462):
            boys_name.update(get_gender_name_single_page(boy_url + str(i)))
        for i in range(1, 316):
            girls_name.update(get_gender_name_single_page(girl_url + str(i)))
        neuter_name = boys_name & girls_name
        boys_name = boys_name - neuter_name
        girls_name = girls_name - neuter_name
        return boys_name, girls_name
    except Exception as e:
        print(e)
        return [['Error'], ['Error']] 

def get_user_gender(self):
        if self.user_url == None:
            print "I'm anonymous user."
            return -1
        else:
            if self.soup == None:
                try:
                    self.parser()
                except:
                    return -1
            soup = self.soup
            if soup.find("span", class_="item gender"):
                gender= soup.find("span", class_="item gender").i["class"][1]
                #print gender
                if gender =='icon-profile-male':
                    self.user_gender = 1
                    return 1
                else:
                    self.user_gender = 0
                    return 0
            else:
                self.user_gender = 2
                return 2 

def get_gender(self):
        """
        Returns the updated time, most recent gender counts, and breakdown of daily
        gender trends.
        """
        api_response = self.course.enrollment(demographics.GENDER, end_date=self.get_current_date())
        recent_genders = None
        trend = None
        last_updated = None
        known_enrollment_percent = None

        if api_response:
            last_updated = self.parse_api_datetime(api_response[-1]['created'])
            recent_genders = self._build_recent_genders(api_response)
            trend = self._build_gender_trend(api_response)
            known_enrollment_percent = self._build_gender_known_percent(api_response)

        return last_updated, recent_genders, trend, known_enrollment_percent 

def get_top_20_gender_neutral(df):
    """Gets the top 20 most used gender neutral names.

    Parameters
    ----------
    df : pandas.DataFrame
        The DataFrame to be analyzed.

    """

    # We pivot the dataframe so the names will be the index and the genders will be the columns.
    df = df.pivot_table(index="name", columns="gender",
                        values="count", aggfunc=np.sum).dropna()

    # Limit to only names with at least 50,000 records on both genders.
    df = df[(df["M"] >= 50000) & (df["F"] >= 50000)]
    print(df.head(20)) 

def get_gender(self):
        """
            By Mukosame (https://github.com/mukosame)
            增加获取知乎识用户的性别

        """
        if self.user_url == None:
            print "I'm anonymous user."
            return 'unknown'
        else:
            if self.soup == None:
                self.parser()
            soup = self.soup
            try:
                gender = str(soup.find("span",class_="item gender").i)
                if (gender == '<i class="icon icon-profile-female"></i>'):
                    return 'female'
                else:
                    return 'male'
            except:
                return 'unknown' 

def get_gender_style(self, person):
        """
        Return gender specific person style.
        """
        gender = person.get_gender()
        shape = "box"
        style = "solid, filled"

        # get alive status of person to get box color
        try:
            alive = probably_alive(person, self.dbstate.db)
        except RuntimeError:
            alive = False

        fill, color = color_graph_box(alive, gender)
        return(shape, style, color, fill) 

def get_gender(number):
    """Get the gender (M/F) from the person's CURP."""
    number = compact(number)
    if number[10] == 'H':
        return 'M'
    elif number[10] == 'M':
        return 'F'
    else:
        raise InvalidComponent()


# characters used for checksum calculation, 

def get_gender(number):
    """Get the person's birth gender ('M' or 'F')."""
    number = compact(number)
    if number[0] in '1357':
        return 'M'
    elif number[0] in '2468':
        return 'F'
    else:
        raise InvalidComponent() 

def get_gender(self, gender_id):
        if gender_id == 1:
            return self.bot.trans.plugins.world_of_warcraft.strings.female
        else:
            return self.bot.trans.plugins.world_of_warcraft.strings.male 

def get_gender(payload, prop_noun_entities):
    gender_req = requests.get("https://api.genderize.io/", params=payload)
    json_gen = gender_req.json()

    for ji in json_gen:
        prop_noun_entities[json_gen[ji]['name']] = json_gen[ji]['gender']

    return prop_noun_entities 

def get_gender_pt(word, text=""):
    # parse gender taking context into account
    word = word.lower()
    words = text.lower().split(" ")
    for idx, w in enumerate(words):
        if w == word and idx != 0:
            # in portuguese usually the previous word (a determinant)
            # assigns gender to the next word
            previous = words[idx - 1].lower()
            if previous in _MALE_DETERMINANTS_PT:
                return "m"
            elif previous in _FEMALE_DETERMINANTS_PT:
                return "f"

    # get gender using only the individual word
    # see if this word has the gender defined
    if word in _GENDERS_PT:
        return _GENDERS_PT[word]
    singular = word.rstrip("s")
    if singular in _GENDERS_PT:
        return _GENDERS_PT[singular]
    # in portuguese the last vowel usually defines the gender of a word
    # the gender of the determinant takes precedence over this rule
    for end_str in _FEMALE_ENDINGS_PT:
        if word.endswith(end_str):
            return "f"
    for end_str in _MALE_ENDINGS_PT:
        if word.endswith(end_str):
            return "m"
    return None 

def get_gender(meta_data, speaker_idx):
        gender_str = meta_data[speaker_idx]['gender']

        if gender_str == 'male':
            return issuers.Gender.MALE
        elif gender_str == 'female':
            return issuers.Gender.FEMALE
        else:
            return issuers.Gender.UNKNOWN 

def get_gender(self):
        """
        Return the gender of the Person.

        :returns: Returns one of the following constants:

                  - Person.MALE
                  - Person.FEMALE
                  - Person.UNKNOWN
        :rtype: int
        """
        return self.__gender 

def get_gender(word, context="", lang=None):
    """ Guess the gender of a word

    Some languages assign genders to specific words.  This method will attempt
    to determine the gender, optionally using the provided context sentence.

    Args:
        word (str): The word to look up
        context (str, optional): String containing word, for context
        lang (str): the BCP-47 code for the language to use, None uses default

    Returns:
        str: The code "m" (male), "f" (female) or "n" (neutral) for the gender,
             or None if unknown/or unused in the given language.
    """

    lang_code = get_primary_lang_code(lang)

    if lang_code in ["pt", "es"]:
        # spanish follows same rules
        return get_gender_pt(word, context)
    elif lang_code == "it":
        return get_gender_it(word, context)
    # TODO: get_gender_xx for other languages
    _log_unsupported_language(lang_code,
                              ['pt', 'it', 'es'])
    return None 

def get_gender_age(args, model_age, model_gender):
    count = 0.;
    age_mae = 0.; age_rmse = 0.;gender_num = 0
    output_data = []
    times = 0.
    labelList = csv.reader(open(args.label, "rt", encoding="utf-8-sig"))
    for row in labelList:
        img_id = row[0]
        true_age = int(row[2])
        true_gender = int(row[1])
        img = cv2.imread(os.path.join(args.image, img_id))
        if img is None:
            continue
        count += 1
        if count % 5000 == 0:
            print(count)
        start_time = time.time()
        face = cv2.resize(img, (args.image_size, args.image_size))
        face = face[np.newaxis, :]
        # age
        predicted_ages = float(model_age.predict(face))
        age_mae += abs(predicted_ages - true_age)
        age_rmse += math.pow(predicted_ages - true_age, 2)
        # gender
        predicted_genders = float(model_gender.predict(face))  # predicted_genders < 0.5 female
        times += (time.time() - start_time)
        if (predicted_genders < 0 and true_gender < 1) or (predicted_genders >= 0 and true_gender > 0):
            gender_num += 1
        output_data.append({'id':img_id, 'true_gender': true_gender, 'true_age': true_age,
                            'estimate_gender': predicted_genders, 'estimate_age':predicted_ages})
    age_mae = age_mae / count
    age_rmse = math.sqrt(age_rmse / count)
    gender_acc = gender_num / count
    print('Mean time:', times/count)

    with open(args.result, 'w') as f:
        headers = ['id', 'true_gender', 'true_age', 'estimate_gender', 'estimate_age']
        f_scv = csv.DictWriter(f, headers)
        f_scv.writeheader()
        f_scv.writerows(np.array(output_data))
    return gender_acc, age_mae, age_rmse 

def get_gender_name_single_page(url, use_proxy=True):
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko'}
    try:
        if use_proxy:
            proxies = ss_proxies
        else:
            proxies = None
        html = requests.get(url, headers=headers, timeout=5, proxies=proxies)
        bsObj = bs(html.text)
        name_list = [i.text for i in bsObj.findAll("span", {"class": "result-name"})]
        return name_list
    except Exception as e:
        print(e)
        return [] 

def get_gender_style(self, person):
        "return gender specific person style"
        gender = person.get_gender()
        shape = "box"
        style = "solid"
        color = ""
        fill = ""

        if gender == person.FEMALE and self.use_roundedcorners:
            style = "rounded"
        elif gender == person.UNKNOWN:
            shape = "hexagon"

        if person == self.center_person and self.increlname:
            shape = "octagon"

        if self.colorize == 'colored':
            if gender == person.MALE:
                color = self.colors['male']
            elif gender == person.FEMALE:
                color = self.colors['female']
            else:
                color = self.colors['unknown']
        elif self.colorize == 'filled':
            style += ",filled"
            if gender == person.MALE:
                fill = self.colors['male']
            elif gender == person.FEMALE:
                fill = self.colors['female']
            else:
                fill = self.colors['unknown']
        return(shape, style, color, fill) 

def get_gender_str(self, person):
        """
        Return gender string of male/female/unknown
        """
        if person.get_gender() == 0:
            return "female"
        elif person.get_gender() == 1:
            return "male"
        else:
            return "unknown" 

def get_gender_mapping(wsj_root: Path):
    spkrinfo_wsj = list(wsj_root.glob('**/wsj?/doc/**/*spkrinfo.txt'))
    spkrinfo_kaldi = list(kaldi_wsj_data_dir.glob('**/*spkrinfo.txt'))
    spkrinfo = spkrinfo_wsj + spkrinfo_kaldi

    if len(spkrinfo) == 0:
        raise RuntimeError(
            f'Could not find "{wsj_root}/**/wsj?/doc/**/*spkrinfo.txt" and'
            f'"{kaldi_wsj_data_dir}/**/*spkrinfo.txt".'
        )
    if len(spkrinfo_wsj) == 0:
        raise RuntimeError(
            f'Could not find "{wsj_root}/**/wsj?/doc/**/*spkrinfo.txt".'
        )
    if len(spkrinfo_kaldi) == 0:
        raise RuntimeError(
            f'Could not find "{kaldi_wsj_data_dir}/**/*spkrinfo.txt". '
            f'Did you forget to run the data preparation for WSJ in Kaldi?'
        )

    _spkr_gender_mapping = dict()

    for path in spkrinfo:
        with open(path, 'r') as fid:
            for line in fid:
                if not (line.startswith(';') or line.startswith('---')):
                    line = line.split()
                    _spkr_gender_mapping[line[0].lower()] = 'male' \
                        if line[1] == 'M' else 'female'

    if len(_spkr_gender_mapping) == 0 or '01i' not in _spkr_gender_mapping:
        raise RuntimeError(
            f'Could not read the gender information from "{spkrinfo}".'
        )

    return _spkr_gender_mapping 

def get_gender_from_label(gender):
    """
    Method to get the passed gender in XNAT format

    :param gender: gender selected
    :return: value accepted by xnat: 'female' or 'male'
    """
    if gender.lower() in ['female', 'f']:
        return 'female'
    elif gender.lower() in ['male', 'm']:
        return 'male'
    else:
        return 'unknown' 

def get_full_gender(self): #Change this to be multilingual
        if(self.gender.lower() == 'm'):
            return "Male"

        if(self.gender.lower() == 'f'):
            return "Female" 

def get_gender_stats(self):
        """
        Returns a dictionary of
        {given_name: (male_count, female_count, unknown_count)}
        """
        gstats = {}
        cursor = self.db.gender_stats.find()
        for doc in cursor:
            gstats[doc["given_name"]] = (doc["male"],
                                         doc["female"],
                                         doc["unknown"])
        return gstats 

def get_gender_view(self):
        """Return the gRPC stub for :meth:`GenderViewServiceClient.get_gender_view`.

        Returns the requested gender view in full detail.

        Returns:
            Callable: A callable which accepts the appropriate
                deserialized request object and returns a
                deserialized response object.
        """
        return self._stubs['gender_view_service_stub'].GetGenderView 

def GetGenderView(self, request, context):
    """Returns the requested gender view in full detail.
    """
    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
    context.set_details('Method not implemented!')
    raise NotImplementedError('Method not implemented!') 

def getGenderType(type, gender, items):
    typeItems = []
    for item in items:
        if getType(item) == type:
            if gender == 'm':
                modelId = getMaleModelId(item)
            else:
                modelId = getFemaleModelId(item)
            if modelId != -1:
                typeItems.append(item)

    return typeItems 

def getGender(img):
    input_image = caffe.io.load_image(img)
    net.blobs['data'].data[...] = transformer.preprocess('data', input_image)
    out = net.forward()
    out_prob = out['prob'][0]
    index = out_prob.argmax()
    return gender_list[index]


# 保存上传文件 

def get_pkm_gender(is_female, has_female):
  if not has_female:
    return ''
  node = 'F' if is_female else 'M'
  expl = 'Female sprite' if is_female else 'Male sprite'
  return { 'node': node, 'expl': expl, 'cls': f' gender-{node.lower()}' } 

def getGender(self):
		
		print ("---" + self.name +"'s Gender Identity, in all relevant forms---")
		print (""" 
     MALE and FEMALE are the most commonly identified genders.
 BEWGor can include (English) synonyms for these two choices if 
 they are entered. You may wish to inlcude synonyms in the
 Subject's native language. For example, a Spanish speaker might
 include "chico" in their password. A German speaker may include "Frau"
    Transgendered or transsexual people may identify as male,
 female, trans, queer or something else. Some people do not identify with
 the concept of a binary Male/Female gender system.
    Note that sexuality is different than gender identity,
 and that there will not be a prompt requesting information
 about sexuality specifically. If you have information you
 wish to include about your subject's sexuality do so in the
 "ADDITIONAL WORDS" prompt at the end of the profiling process.
 
    Use 'male' or 'female' to bring up a prompt to include synonyms.
 """)
 
		gender_cands =[] #list that will contain inputted genders, or return blank if none are given
		entered = []
		
		gender = raw_input("> Enter a value for " + self.name +"'s Identified Gender, or press enter to move on >:")
		while len(gender) != 0:
			
			
			if nonzero_blankspace_reg.match(gender): #ensures input isn't only blank space characters
				print (" [-] Empty Space, try again.")
				gender = raw_input("> Enter a value for " + self.name +"'s Identified Gender, or press enter to move on >:")
				
			elif not location_chars_reg.match(gender): #checks to see if input contains any characters unlikely to be in this category
				print (" [-] Input contains invalid characters, try again.")
				gender = raw_input("> Enter a value for " + self.name +"'s Identified Gender, or press enter to move on >:")
				
			elif gender in gender_cands or gender in entered: #check for double input
				print (" [-] That input has already been added to the list.\n  Some inputs are added automatically, try again.")
				gender = raw_input("> Enter a value for " + self.name +"'s Identified Gender, or press enter to move on >:")
				
			else:
				if ' ' in gender and not male_reg.match(gender) and not female_reg.match(gender):
				#if a gender contains spaces, split it up so BEWGor can join the words together with variations
					
					gender_cands.extend((spaceHandler(gender))) #create variants of input if input contains spaces
					entered.append(gender) #adds to 'entered' list to prevent double-adds	
					gender = raw_input("> Enter a value for " + self.name +"'s Identified Gender, or press enter to move on >:")
					
				else:
					gender_cands.append(gender.lower()) 
					
					if male_reg.match(gender):
						gender_cands.append('male')
						entered.append('male')
						
						male_syn_choice = raw_input('> Would you like to include 10 English synonyms for Male? (Y/N) >:').upper()
						male_syn_choice = spaceShaver(male_syn_choice)	
						
						if male_syn_choice in "YES" and len(male_syn_choice) != 0:
							gender_cands.extend(['man','bro','dude','sir','gent','mr','mister','guy','boy','boi'])
							print ('\n [+] Synonyms for Male added \n')
					
					if female_reg.match(gender):
						gender_cands.append('female')
						entered.append('female')
						
						fem_syn_choice = raw_input('> Would you like to include 10 English synonyms for Female? (Y/N) >:').upper()
						fem_syn_choice = spaceShaver(fem_syn_choice)	

						if fem_syn_choice in "YES" and len(fem_syn_choice) != 0:
							gender_cands.extend(['woman','girl','gal','chick','lady','mrs','ms','miss','misses','grrl','gurl','madame'])
					
					entered.append(gender)
					
					gender = raw_input("> Enter a value for " + self.name +"'s Identified Gender, or press enter to move on >:")
					print ('\n [+] Synonyms for Female added \n')
					
		gender_cands=list(set(gender_cands))  #removes duplicates from list	
		self.gender = ' '.join(gender_cands)  #change value to entry - including to a null value if nothing is entered

	#Requests Main Subject's Country of Origin