Esempio n. 1
0
 def clean_word(self, word):
     if isinstance(word, str):
         return singularize(word.lower()) if singularize(word.lower()) not in self.stop_words else None
     elif isinstance(word, list):
         return [singularize(w.lower()) for w in word if w not in self.stop_words]
     else:
         raise ValueError()
Esempio n. 2
0
File: view.py Progetto: zabano/geopd
def before_request():
    if current_user.is_authenticated:
        if request.endpoint == 'web.show_core':
            if 1 == randint(1, 2):
                if not current_user.bio.research_interests or not current_user.bio.research_experience:
                    flash(Markup(
                        'Your biography is not up to date. '
                        '<a href="{0}" class="alert-link">Update my biography</a>.'.format(
                            url_for('show_user', user_id=current_user.id))), category='warning')
                else:
                    for user_survey in current_user.surveys.values():
                        if not user_survey.completed_on:
                            parent_type, parent_id = user_survey.survey.parent_type, user_survey.survey.parent_id
                            if parent_type and parent_id:
                                endpoint = 'web.show_{0}'.format(singularize(parent_type))
                                view_args = {'{0}_id'.format(singularize(parent_type)): parent_id}
                                url = url_for(endpoint, **view_args)
                            else:
                                url = url_for('show_user', user_id=current_user.id)
                            flash(Markup(
                                'You have not completed the survey. Please complete the '
                                '<a href="{href}#survey" class="alert-link">{title}</a>.'.format(
                                    href=url,
                                    title=user_survey.title
                                )), category='warning')
                            break
Esempio n. 3
0
 def put(self, id_object, resource=None, **kwargs):
     resource = resource or self.resource
     url = "{}/{}.json".format(resource, id_object)
     data = {singularize(resource): kwargs}
     resp = self.base._request(url, 'PUT', **data)
     if resp.status_code != 200:
         content = safe_get_json(resp)
         raise RequestException(resp.status_code, content=content)
     return self.class_object(**resp.json().get(singularize(resource)))
Esempio n. 4
0
 def create(self, resource=None, **kwargs):
     resource = resource or self.resource
     url = "{}.json".format(resource)
     singular_resource = singularize(resource)
     data = {
         singular_resource: kwargs,
     }
     resp = self.base._request(url, 'POST', **data)
     if resp.status_code != 201:
         content = resp.json() if getattr(resp, 'json') else {}
         raise RequestException(resp.status_code, content=content)
     return self.class_object(**resp.json().get(singularize(resource)))
    def compute_metadata_score(self, stream_info, query_str): 
        TYPE = 1

        metadata_features = {'title': 0, 'rating': -1, 'description': 0, 'viewcount': -1, 'dislikes':-1, 'likes': -1,  'keywords': 0}
        query_words = query_str.split()

        # 
        words = stream_info['ftitle'].split('_')
        for q_w in query_words:
            for w in words:
                w = inflection.singularize(w.lower())
                if w.find(q_w) >= 0:
                    metadata_features['title'] += 1
                    break
        #
        metadata_features['rating'] = self.get_type_score(stream_info['rating'], 'rating', TYPE)
        
        #
        words = stream_info['description'].split()
        for q_w in query_words:
            for w in words:
                w = inflection.singularize(w.lower())
                if w.find(q_w) >= 0:
                    metadata_features['description'] += 1
                    break
        #
        metadata_features['viewcount'] = self.get_type_score(stream_info['viewcount'], 'viewcount', TYPE)
        #
        metadata_features['dislikes'] = self.get_type_score(stream_info['dislikes'], 'dislikes', TYPE)
        #
        metadata_features['likes'] = self.get_type_score(stream_info['likes'], 'likes', TYPE)

        #
        for q_w in query_words:        
            for w in stream_info['keywords']:
                w = inflection.singularize(w.lower())
                if w.find(q_w) >= 0:
                    metadata_features['keywords'] += 1
                    break
        
        # compute score
        score = 0
        if metadata_features['title'] or metadata_features['description'] or metadata_features['keywords']: 
            score = metadata_features['title'] + metadata_features['description'] + metadata_features['keywords']
            
            #for key in metadata_features.keys():
            #    score += metadata_features[key] 

        return score, metadata_features['viewcount']
Esempio n. 6
0
def test_uncountable_word_is_not_greedy():
    uncountable_word = "ors"
    countable_word = "sponsor"

    inflection.UNCOUNTABLES.add(uncountable_word)
    try:
        assert uncountable_word == inflection.singularize(uncountable_word)
        assert uncountable_word == inflection.pluralize(uncountable_word)
        assert inflection.pluralize(uncountable_word) == inflection.singularize(uncountable_word)

        assert "sponsor" == inflection.singularize(countable_word)
        assert "sponsors" == inflection.pluralize(countable_word)
        assert "sponsor" == inflection.singularize(inflection.pluralize(countable_word))
    finally:
        inflection.UNCOUNTABLES.remove(uncountable_word)
Esempio n. 7
0
def generate_model_name(name):
    """ Generate model name.

    :param name: String representing a field or route name.
    """
    model_name = inflection.camelize(name.strip('/'))
    return inflection.singularize(model_name)
Esempio n. 8
0
    def handle(self):
        name = self.argument('name')
        singular = inflection.singularize(inflection.tableize(name))
        directory = self._get_path()
        filepath = self._get_path(singular + '.py')

        if os.path.exists(filepath):
            raise RuntimeError('The model file already exists.')

        mkdir_p(directory)

        parent = os.path.join(directory, '__init__.py')
        if not os.path.exists(parent):
            with open(parent, 'w'):
                pass

        stub = self._get_stub()
        stub = self._populate_stub(name, stub)

        with open(filepath, 'w') as f:
            f.write(stub)

        self.info('Model <comment>%s</> successfully created.' % name)

        if self.option('migration'):
            table = inflection.tableize(name)

            self.call(
                'make:migration',
                [
                    ('name', 'create_%s_table' % table),
                    ('--table', table),
                    ('--create', True)
                ]
            )
    def gen_db_model(self, schema_name, table_name):
        sql = """ SELECT column_name, column_default, data_type, column_key, is_nullable,
                         character_maximum_length, column_comment
                  FROM information_schema.columns
                  WHERE TABLE_SCHEMA = :schema_name AND
                        TABLE_NAME = :table_name
                  ORDER BY ORDINAL_POSITION"""

        with self.create_session(self._default_db) as session:
            entities = session.execute(sql, dict(schema_name=schema_name, table_name=table_name))
            metas = [GenMeta(entity) for entity in entities if entity[0] != 'pkid']
            model_meta = DbModelMeta()
            model_meta.table_metas = metas
            for meta in metas:
                if model_meta.has_id is False:
                    model_meta.has_id = meta.column_name == 'id'
                    model_meta.is_string_id = meta.column_name == 'id' and \
                                              u'varchar' == meta.data_type
                if model_meta.has_created_at is False:
                    model_meta.has_created_at = meta.column_name == 'created_at'
                if model_meta.has_updated_at is False:
                    model_meta.has_updated_at = meta.column_name == 'updated_at'
                if model_meta.has_is_deleted is False:
                    model_meta.has_is_deleted = meta.column_name == 'is_deleted'
            model_meta.class_name = inflection.singularize(inflection.camelize(table_name))

            template_path = os.path.join(os.path.dirname(__file__))
            t = Loader(template_path, **{}).load('model.tpl')
            print t.generate(**model_meta.__dict__)
Esempio n. 10
0
    def _resolve_obj_from_path(self, path_str, params):
        """

        :param path_str: stripped (no extra slashes)
        :return: new obj
        """
        obj = {}
        if path_str == '0':
            obj['name'] = 'jonathan'
            self._set_cached_obj(path_str, '0', obj) # add proper fields to obj and assign path and id globally to it
            obj.update(self._get_meta(params, ['name', 'id', 'birthday'], ['photos', 'feed', 'albums'], 'user'))
            return obj
        m = re.search('[0|me]/(photos|albums|feed)([0-9]+)$', path_str)
        if m:
            type = singularize(m.group(1))
            id = m.group(2)
            if int(id) < 100:
                raise NoSuchPathException(path_str)
            obj['type'] = type

            self._set_cached_obj(path_str, str(id), obj)
            if type == 'photo':
                fields = ['id', 'created_time']
                connections = ['comments', 'likes']
            elif type == 'album':
                fields = ['id', 'cover_photo']
                connections = ['comments', 'photos']
            elif type == 'feed':
                fields = ['id', 'message', 'story']
                connections = ['comments', 'attachments']
            obj.update(self._get_meta(params, fields, connections, type))
            return obj
        raise NoSuchPathException(path_str)
Esempio n. 11
0
def get_response_query_template(service, operation):
    """refers to definition of API in botocore, and autogenerates template
    Assume that response format is xml when protocol is query

    You can see example of elbv2 from link below.
      https://github.com/boto/botocore/blob/develop/botocore/data/elbv2/2015-12-01/service-2.json
    """
    client = boto3.client(service)
    aws_operation_name = to_upper_camel_case(operation)
    op_model = client._service_model.operation_model(aws_operation_name)
    result_wrapper = op_model.output_shape.serialization['resultWrapper']
    response_wrapper = result_wrapper.replace('Result', 'Response')
    metadata = op_model.metadata
    xml_namespace = metadata['xmlNamespace']

    # build xml tree
    t_root = etree.Element(response_wrapper,  xmlns=xml_namespace)

    # build metadata
    t_metadata = etree.Element('ResponseMetadata')
    t_request_id = etree.Element('RequestId')
    t_request_id.text = '1549581b-12b7-11e3-895e-1334aEXAMPLE'
    t_metadata.append(t_request_id)
    t_root.append(t_metadata)

    # build result
    t_result = etree.Element(result_wrapper)
    outputs = op_model.output_shape.members
    replace_list = []
    for output_name, output_shape in outputs.items():
        t_result.append(_get_subtree(output_name, output_shape, replace_list))
    t_root.append(t_result)
    xml_body = etree.tostring(t_root, pretty_print=True).decode('utf-8')
    xml_body_lines = xml_body.splitlines()
    for replace in replace_list:
        name = replace[0]
        prefix = replace[1]
        singular_name = singularize(name)

        start_tag = '<%s>' % name
        iter_name = '{}.{}'.format(prefix[-1], name.lower())if prefix else name.lower()
        loop_start = '{%% for %s in %s %%}' % (singular_name.lower(), iter_name)
        end_tag = '</%s>' % name
        loop_end = '{{ endfor }}'

        start_tag_indexes = [i for i, l in enumerate(xml_body_lines) if start_tag in l]
        if len(start_tag_indexes) != 1:
            raise Exception('tag %s not found in response body' % start_tag)
        start_tag_index = start_tag_indexes[0]
        xml_body_lines.insert(start_tag_index + 1, loop_start)

        end_tag_indexes = [i for i, l in enumerate(xml_body_lines) if end_tag in l]
        if len(end_tag_indexes) != 1:
            raise Exception('tag %s not found in response body' % end_tag)
        end_tag_index = end_tag_indexes[0]
        xml_body_lines.insert(end_tag_index, loop_end)
    xml_body = '\n'.join(xml_body_lines)
    body = '\n{}_TEMPLATE = """{}"""'.format(operation.upper(), xml_body)
    return body
Esempio n. 12
0
 def __init__(self, resource, **kwargs):
     self.save = self.__save
     self.resource = resource
     self.__dict__ = kwargs
     singular_resource = singularize(resource)
     name_custom_fields = '{}_fields'.format(singular_resource)
     self.CustomFields = CustomFields(**kwargs.pop(name_custom_fields, {}))
     map(lambda x: setattr(self, x[0], x[1]), kwargs.items())
Esempio n. 13
0
 def __add_resource(self, resource):
   """
   Add a vanilla resource.
   """
   resource  = inflection.singularize(resource)
   item      = getattr(self.cli, 'new_' + resource)()
   create    = getattr(self.dao, 'create_' + resource)
   create(item)
Esempio n. 14
0
def longflag(param):
    if len(param.name) > 1:
        x = param.name.replace('_', '-')
        if param.annotation in {list, COUNT}:
            y = singularize(x)
        else:
            y = x
        return '--' + y
Esempio n. 15
0
def reduce_flatten_dto(dto, known_dto, config, suggested_name=None):
    if isinstance(dto, list):
        elements_type = None
        for item in dto:
            if isinstance(item, dict):
                new_dto = reduce_flatten_dto(item, known_dto, config, suggested_name)
                element_type = new_dto.name
            else:
                element_type = get_type_name(item)
            if element_type:
                if not elements_type:
                    elements_type = element_type
                elif elements_type != element_type:
                    elements_type = get_type_name(object)
        return elements_type
    elif isinstance(dto, dict):
        fields = []
        dto_name = suggested_name
        for key, value in dto.items():
            if value is not None:
                field = None
                if isinstance(value, dict):
                    element_name = key
                    # parse special attribute to get dto name
                    if all(d.name != element_name for d in known_dto):
                        new_dto = reduce_flatten_dto(value, known_dto, config, element_name)
                        element_name = new_dto.name
                    field = FieldDescription(key, element_name)
                elif isinstance(value, list):
                    element_name = inflection.singularize(key)
                    elements_type = reduce_flatten_dto(value, known_dto, config, element_name)
                    if not elements_type:
                        elements_type = inflection.singularize(key)
                    field = FieldDescription(key, get_type_name(value), elements_type)
                else:
                    if key == "__name__":
                        dto_name = value
                    else:
                        field = FieldDescription(key, get_type_name(value))
                if field is not None:
                    fields.append(field)
        new_dto = DtoDescription(dto_name, fields)
        update_dtos(known_dto, new_dto)
        return new_dto
    return known_dto
Esempio n. 16
0
def metadata_Breed(data, breed_label):
    breed_array = np.zeros((len(data), 370))
    for i in range(len(data)):
        word_list2 = set([
            inflection.singularize(x)
            for x in data['metadata_annots_top_desc'][i].split(' ')
        ])
        for c, bn in enumerate([
                inflection.singularize(x).lower()
                for x in breed_label.BreedName.values
        ]):
            breed_array[i, c] = int(bn in word_list2)
    metadata_breed = pd.DataFrame(breed_array)
    metadata_breed.columns = [
        'metadata_breed_' + str(x) for x in range(breed_array.shape[1])
    ]
    data = pd.concat([data, metadata_breed], axis=1)
    return data
Esempio n. 17
0
def inflect_given_cardinality(word, num_items):
    """
    Return the singular form of the word if `num_items` is 1.  Otherwise,
    return the plural form of the word.
    """
    if num_items == 1:
        return singularize(word)
    else:
        return pluralize(word)
Esempio n. 18
0
 def create(cls, zendesk, **kwargs):
     resource = "{}.json".format(cls.resource)
     singular_resource = singularize(cls.resource)
     data = {singular_resource: kwargs}
     resp = zendesk._request(resource, 'POST', **data)
     if resp.status_code != 201:
         from exceptions import RequestException
         raise RequestException(resp.status_code)
     return cls(**resp.json().get(singular_resource))
Esempio n. 19
0
    def singular(self, text: str) -> str:
        if text in self.__singular_cache:
            return self.__singular_cache[text]

        singular_text = inflection.singularize(text)

        self.__singular_cache[text] = singular_text

        return singular_text
Esempio n. 20
0
def generate_model_name(raml_resource):
    """ Generate model name.

    :param raml_resource: Instance of ramlfications.raml.ResourceNode.
    """
    resource_uri = get_resource_uri(raml_resource).strip('/')
    resource_uri = re.sub('\W', ' ', resource_uri)
    model_name = inflection.titleize(resource_uri)
    return inflection.singularize(model_name).replace(' ', '')
Esempio n. 21
0
def generate_model_name(raml_resource):
    """ Generate model name.

    :param raml_resource: Instance of ramlfications.raml.ResourceNode.
    """
    resource_uri = get_resource_uri(raml_resource).strip('/')
    resource_uri = re.sub('\W', ' ', resource_uri)
    model_name = inflection.titleize(resource_uri)
    return inflection.singularize(model_name).replace(' ', '')
Esempio n. 22
0
 def type(string: str):
     try:
         prefix, resulting_type = Naming.pop_prefix(string)
         prefix += Naming.TYPE_PREFIX
     except IndexError:
         prefix = ""
         resulting_type = string
     resulting_type = inflection.singularize(resulting_type) if Naming._pluralize(resulting_type) else resulting_type
     return prefix + inflection.camelize(resulting_type)
Esempio n. 23
0
File: lib.py Progetto: kreopt/aioweb
def names(word, format=[]):
    ret = {}
    ret["table"] = inflection.tableize(word)
    ret["model"] = inflection.singularize(ret["table"])
    ret["class"] = inflection.camelize(ret["model"])
    ret["crud_class"] = inflection.camelize(ret["table"] + "_controller")
    if not format:
        return ret
    ret = [ret[k] for k in format]
    return ret[0] if len(ret) == 1 else ret
Esempio n. 24
0
    def __init__(self, data):

        self.initDatabaseDictionaries()
        self.words = word_tokenize(data.lower())
        self.wordsUnFiltered = nltk.pos_tag(self.words)
        self.wordsTagged = []
        for wt in self.wordsUnFiltered:
            if wt[0] not in self.stopWords:
                tuple = (singularize(wt[0]), wt[1])
                self.wordsTagged.append(tuple)
def check_object(job, activity, obj):
    if not obj:
        activity.end_date = datetime.datetime.now()
        activity.status = 3
        job.overall_status = 3
        job.status_message = "%s Definition not found" % inflection.singularize(job.activity_type).title()
        job.end_date = datetime.datetime.now()
        db.session.commit()
        return False
    return True
Esempio n. 26
0
 def preprocess(self, text):
     text = text.encode('ascii', 'ignore').lower()
     text = ZEPreprocessor.replace_numeral_words(text)
     text = ZEPreprocessor.re_irrelation.sub(' ', text)
     text = ZEPreprocessor.re_single_space.sub('', text)
     text = ZEPreprocessor.re_phone_number.sub('', text)
     text = text.split('\n')
     text = [' '.join([inflection.singularize(token)
                       for token in _.split(' ')]) for _ in text]
     return text
Esempio n. 27
0
 def __delete_resource(self, resource, resource_id=None):
   """
   Delete a vanilla resource.
   """
   resource = inflection.singularize(resource)
   if not resource_id:
     item = getattr(self.cli, 'search_' + resource)()
     resource_id = item.id
   delete = getattr(self.dao, 'delete_' + resource)
   delete(resource_id)
Esempio n. 28
0
    def serialise(self):
        import inflection
        import binascii
        import simplejson

        # 'proposal', 'superblock', etc.
        name = self._meta.name
        obj_type = inflection.singularize(name)

        return binascii.hexlify(simplejson.dumps((obj_type, self.get_dict()), sort_keys=True).encode('utf-8')).decode('utf-8')
Esempio n. 29
0
def standardize(ingredients):
    recipe = []
    for ing in ingredients:
        temp = ''

        ing = ing.lower()
        ing = unidecode.unidecode(ing)

        ing = ing.split(" or ")[0]
        ing = re.sub(r"[\(\[].*?[\)\]]", " ", ing)
        ing = re.sub(r"([0-9]*-ounces)+", " ", ing)
        ing = re.sub(r"([0-9]*-ounce)+", " ", ing)
        ing = re.sub(r"([0-9]*-inches)+", " ", ing)
        ing = re.sub(r"([0-9]*-inch)+", " ", ing)
        ing = re.sub(r"([0-9])+", " ", ing)
        ing = re.sub(r"(-)+", " ", ing)
        ing = re.sub(r"(/)+", " ", ing)
        ing = ing.split(",")[0]
        ing = ing.replace("*", " ")
        ing = ing.replace("%", " ")

        ing = ing.replace("+", " ")
        ing = ing.replace("-", " ")
        ing = ing.replace(".", " ")
        ing = ing.replace(":", " ")
        ing = ing.replace("(", " ")
        ing = ing.split("http")[0]

        wi = TextBlob(ing)
        tagbag = wi.tags

        for pos in tagbag:
            if (pos[1] in tags) or (singularize(pos[0]) in allow):
                if singularize(pos[0]) not in stopWords:

                    temp = temp + " " + singularize(pos[0])
        temp = temp.strip()

        if temp:
            recipe.append(temp)
            ingredients_set.append(temp)

    return list(set(recipe))
Esempio n. 30
0
def register_blueprints(flask, package):
    package_dir = path.join(getcwd(), __name__, package)
    module_suffix = '_' + singularize(package) + '.py'

    module_names = [sub('\.py$', '', c)
                    for c in listdir(package_dir) if c.endswith(module_suffix)]

    for module_name in module_names:
        module = import_module(__name__ + '.%s.%s' % (package, module_name))
        flask.register_blueprint(module.blueprint)
Esempio n. 31
0
def standardize(ingredients):
    recipe = []
    for flag, ing in ingredients:
        temp = ''
        # print(ing)
        # ing = '1 1/4 cups all-purpose flour (about 5 1/2 ounces)'
        ing = ing.lower()
        ing = unidecode.unidecode(ing)

        ing = ing.split(" or ")[0]
        ing = re.sub(r" ?\([^)]+\)", "", ing)
        ing = re.sub(r"([0-9]*-ounces)+", "", ing)
        ing = re.sub(r"([0-9]*-ounce)+", "", ing)
        ing = re.sub(r"([0-9]*-inches)+", "", ing)
        ing = re.sub(r"([0-9]*-inch)+", "", ing)
        ing = re.sub(r"([0-9]*)+", "", ing)
        ing = re.sub(r"(-)+", "", ing)
        ing = re.sub(r"(/)+", "", ing)
        commasplit = re.split(r"\,", ing)
        ing = commasplit[0]
        ing = ing.replace("*", "")
        ing = ing.replace("+", "")
        ing = ing.replace("-", "")
        ing = ing.replace(".", "")
        ing = ing.replace(":", "")
        ing = ing.replace("(", "")
        ing = ing.split("http")[0]

        wi = TextBlob(ing)

        tagbag = wi.tags

        for pos in tagbag:
            if (pos[1] in tags) or (singularize(pos[0]) in allow):
                if singularize(pos[0]) not in stopWords:
                    temp = temp + " " + singularize(pos[0])
        temp = re.sub(r"^\s+", "", temp)
        temp = re.sub(r"\s+$", "", temp)

        if temp != "":
            recipe.append((flag, temp))

    return recipe
Esempio n. 32
0
 def navigate_to_project_page(self, entity_type=''):
     """Navigates to a project entity query page"""
     # clean up the entity_type
     entity_type = inflection.singularize(inflection.camelize(entity_type))
     # Form the url...
     url = '%s/page/project_default?entity_type=%s&project_id=%s' %(self.baseUrl, entity_type, self.project_id)
     # Get the url...
     self.get(url)
     # Ensure the page is loaded...
     self.wait_for_page_to_load()
Esempio n. 33
0
 def type(string: str):
     try:
         prefix, resulting_type = Naming.pop_prefix(string)
         prefix += Naming.TYPE_PREFIX
     except IndexError:
         prefix = ''
         resulting_type = string
     resulting_type = inflection.singularize(
         resulting_type) if Naming._pluralize(
             resulting_type) else resulting_type
     return prefix + inflection.camelize(resulting_type)
Esempio n. 34
0
    def get_model(self, resource_name):
        """Returns the model :class:`flask.ext.sqlalchemy.Model`
        for a resource.

        :param resource_name: name of resource
        """
        resource_name = singularize(resource_name)
        if resource_name not in self._model_for_resources:
            raise UnableToProcess('Resource Error',
                                  'Resource [%s] not found' % resource_name)
        return self._model_for_resources[resource_name]
Esempio n. 35
0
    def get_cfg(self, resource_name):
        """Returns the :class:`flask_resteasy.configs.APIConfig` for
        a resource.

        :param resource_name: name of resource
        """
        resource_name = singularize(resource_name)
        if resource_name not in self._cfg_for_resources:
            raise UnableToProcess('Resource Error',
                                  'Resource [%s] not found' % resource_name)
        return self._cfg_for_resources[resource_name]
Esempio n. 36
0
    def get_model(self, resource_name):
        """Returns the model :class:`flask.ext.sqlalchemy.Model`
        for a resource.

        :param resource_name: name of resource
        """
        resource_name = singularize(resource_name)
        if resource_name not in self._model_for_resources:
            raise UnableToProcess('Resource Error',
                                  'Resource [%s] not found' % resource_name)
        return self._model_for_resources[resource_name]
Esempio n. 37
0
    def next(self, token):
        token = inflection.singularize(token)

        # Fixing nonsensical singularization
        if token in ['ha', 'contain', 'shoe']:
            token += 's'

        self.state = self.state.next(token)

        if type(self.state) is UnexpectedState:
            print "UnexpectedState!"
Esempio n. 38
0
    def get_cfg(self, resource_name):
        """Returns the :class:`flask_resteasy.configs.APIConfig` for
        a resource.

        :param resource_name: name of resource
        """
        resource_name = singularize(resource_name)
        if resource_name not in self._cfg_for_resources:
            raise UnableToProcess('Resource Error',
                                  'Resource [%s] not found' % resource_name)
        return self._cfg_for_resources[resource_name]
Esempio n. 39
0
 def type(string: str):
     try:
         prefix, resulting_type = Naming.pop_prefix(string)
         prefix += Naming.TYPE_PREFIX
     except IndexError:
         prefix = ''
         resulting_type = string
     resulting_type = singularize(resulting_type) if Naming._pluralize(
         resulting_type) else resulting_type
     resulting_type = resulting_type.replace(
         '-', '_')  # camelize does not convert '-' but '_'
     return prefix + camelize(resulting_type)
Esempio n. 40
0
def to_singular_pascal_case(name: str):
    """Make any string into a singular "PascalCased" string.

    Args:
        name (str): The string to convert.

    Returns:
        str: The converted string.
    """
    return inflection.singularize(
        inflection.camelize(
            inflection.parameterize(inflection.titleize(name), separator="_")))
Esempio n. 41
0
    def augment_depends_on_one_get(self, attributes, name):
        _get_method = inflection.singularize(name)
        _key = inflection.dasherize(
                inflection.underscore(
                    inflection.singularize(self.klass)))
        _get_config_method = inflection.pluralize(name)

        if 'dependencies' not in attributes:
            attributes['dependencies'] = set()
        attributes['dependencies'].add(_get_method)

        def get(this):
            name = inflection.dasherize(inflection.underscore(this.__class__.__name__))
            if _key not in this.config:
                return None

            return next(val for key, val in
                    this.env.config.get(_get_config_method).iteritems() if
                    (val.name == this.config[_key]))
        attributes[_get_method] = get
        return _get_method
def folder_has_items(folder_id, folder_type):
    sql = "select count(*) from %s where folder_id = %s" % (
        inflection.singularize(folder_type), folder_id)
    try:
        result = db.engine.execute(sql)
        for row in result:
            if int(row[0]) > 0:
                return True
        return False
    except Exception as ex:
        print ex
        return True
Esempio n. 43
0
def singularize_token(tkn, lookup_table, micro_status):
    lemma=tkn
    if (tkn.endswith("us") or tkn.endswith("ia") or tkn.endswith(
            "ta")):  # for inflection exception in general-takes into account both lower and upper case (apart from some inflection-exception list used also in next
        lemma = tkn
    elif (tkn not in lookup_table[
        "inflection_exceptions"]):  # Further Inflection Exception list is taken into account
        lemma = inflection.singularize(tkn)
    if (tkn != lemma):  # Only in case when inflection makes some changes in lemma
        micro_status.append("Inflection (Plural) Treatment: " + tkn)

    return lemma
Esempio n. 44
0
    def censor(input_text):
        """ Returns input_text with any profane words censored """
        bad_words = self.get_profane_words()

        spl = input_text.split(' ')

        for index, value in spl:
            word = singularize(value)
            if word in bad_words:
                spl[index] = '*' * len(value)

        return ' '.join(spl)
Esempio n. 45
0
def generatePair(opinionList, featureList):
    pair = {}
    for (key, group) in featureList.groupby("business_id"):
        opinion = opinionList[key]
        pair[key] = []
        feature = list(group["featureList"])[0]
        for f in feature:
            attribute = [jj for (nn, jj) in opinion if singularize(nn) == f]
            if attribute:
                result = [(f, attr) for attr in attribute]
                pair[key].extend(result)
    return pair
Esempio n. 46
0
 def singularize_rule(self):
     item = self.item
     if len(item['prioritized_docids']) < 1:
         claim_tokens = item['claim_tokens']
         # finded_keys  = item['prioritized_docids']
         claim_tokens = [inflection.singularize(c) for c in claim_tokens]
         claim = ' '.join(claim_tokens)
         fkd_new, fk_new = self._keyword_match(claim, raw_set=True)
         # finded_keys = set(finded_keys) | set(fk_new)
         item['prioritized_docids'] = list(fk_new)
         item['structured_docids'] = fkd_new
     return self
Esempio n. 47
0
def test_uncountable_word_is_not_greedy():
    uncountable_word = "ors"
    countable_word = "sponsor"

    inflection.UNCOUNTABLES.add(uncountable_word)
    try:
        assert uncountable_word == inflection.singularize(uncountable_word)
        assert uncountable_word == inflection.pluralize(uncountable_word)
        assert(
            inflection.pluralize(uncountable_word) ==
            inflection.singularize(uncountable_word)
        )

        assert "sponsor" == inflection.singularize(countable_word)
        assert "sponsors" == inflection.pluralize(countable_word)
        assert (
            "sponsor" ==
            inflection.singularize(inflection.pluralize(countable_word))
        )
    finally:
        inflection.UNCOUNTABLES.remove(uncountable_word)
def cleaning_data_function_new(text):
    text = text.lower()
    words = re.split(r'\n', text)
    for word in words:
        text1 = ProgRoman.sub(' ', word)
        split = re.split(r' ', text1)
        msg = [
            inflection.singularize(text2) for text2 in split
            if (text2 not in stoplist) and (len(text2) > 2)
        ]
        new1.append(msg)
    return new1
Esempio n. 49
0
 def from_json(cls, name: str, data: str, skip_fields_with_errors=False):
     data = json.loads(data)
     # TODO: More useful support for lists
     # TODO: Bubble up a warning that we ignored everything except the first nonlist item
     if isinstance(data, list):
         if len(data) == 0:
             raise NotImplementedError("Top-level array cannot be an empty list")
         items_name = pluralize(name)
         if singularize(items_name) == name:
             items_name = "items"
         return cls.from_dict(name, {items_name: data}, skip_fields_with_errors)
     return cls.from_dict(name, data, skip_fields_with_errors)
Esempio n. 50
0
def sanitize_name(name):
    singular = inflection.singularize(name)
    plural = name
    if singular == name:
        plural = inflection.pluralize(name)

    num = 2
    while os.path.exists(plural + '.py'):
        plural = plural + str(num)
        num = num + 1

    class_name = inflection.camelize(singular)
    return singular, plural, class_name
Esempio n. 51
0
 def singularize_rule(self):
     """Singularize words
     """
     item = self.item
     if len(item['prioritized_docids']) < 1:
         claim_tokens = item['claim_tokens']
         # finded_keys  = item['prioritized_docids']
         claim_tokens = [inflection.singularize(c) for c in claim_tokens]
         claim = ' '.join(claim_tokens)
         fk_new = self._keyword_match(claim)
         # finded_keys = set(finded_keys) | set(fk_new)
         item['prioritized_docids'] = list(fk_new)
     return self
Esempio n. 52
0
    def augment(self, attributes, name):
        _get_method = self.augment_depends_on_one_get(attributes, name)

        _create = call_parents('create')
        if 'create' in attributes:
            _create = attributes['create']
        def create(self):
            item = getattr(self, _get_method)()
            if item and (not item.created()):
                item.create()
            _create(self)
        attributes['create'] = create
        return {inflection.singularize(name): None}
Esempio n. 53
0
    def __get_raw_data__(self):
        if self._raw_data:
            return self._raw_data

        cls = self.__class__
        params = {'id': str(self.code)}
        options = Util.merge_options('params', params, **self.options)

        path = Util.constructed_path(cls.get_path(), options['params'])

        r = Connection.request('get', path, **options)
        response_data = r.json()
        Util.convert_to_dates(response_data)
        self._raw_data = response_data[singularize(cls.lookup_key())]
        return self._raw_data
Esempio n. 54
0
def inflect(that,word):
    """

    :param that: some object;  if it has a length,  we use that
    :param word: this word will be made singular or plural depending on the singularity or plurarlity of that
    :return: inflected word
    """

    try:
        cnt = len(that)
    except TypeError:
        cnt = 1

    inflected_word = singularize(word) if cnt == 1 else pluralize(word)
    return f"{cnt} {inflected_word}"
Esempio n. 55
0
def singularize(word):
    '''
    Return the singular form of the given word.
    TODO: Check that word is a noun (or an adjective or at any rate can
    be sensibly used as a noun) before calling inflection.singularize?
    FIXME BUGS: inflection returns many wrong answers by pattern:
        *aves -> *afe
    It uses incomplete special case matching (octopus),
    and does not recognize many other pairs such as:
        (locus, loci)
    NB: pattern3.en is not yet functional (2017.07.10)
    '''
    if word.lower()[-4:] == 'aves':
        return word.rstrip('sS')
    return inflection.singularize(word)
Esempio n. 56
0
    def __init__(self, klass, other, rel_column=None, backref=None, **kwargs):
        self.klass = klass
        self.other = other
        if rel_column:
            prop_name = inflection.pluralize(backref) # phonenumbers
            backref_id = rel_column # owner_id
            backref = backref_id.split('_id')[0] # parent
        else:
            # user.projects
            prop_name = inflection.pluralize(self.klass.__name__).lower()
            # project.user_id
            backref_id = '%s_id' % inflection.singularize(self.other.__name__).lower()
            # project.user
            backref = inflection.singularize(self.other.__name__).lower()


        setattr(other, prop_name, self)
        self.rel_column = backref_id
        column = Column(ObjectId)
        column.name = backref_id
        klass.__columns__[backref_id] = column
        setattr(klass, backref_id, column)
        setattr(klass, backref, RelationshipHasOne(klass, other, backref_id))
        print ">>>", backref
Esempio n. 57
0
def name_or_flag(has_keyword_only, param):
    def _name_or_flag(p):
        name = p.name.replace('_', '-')
        if p.default == p.empty or (has_keyword_only and p.kind == p.POSITIONAL_OR_KEYWORD):
            return p.name
        elif len(name) == 1:
            return '-' + name
        else:
            return '--' + name
    try:
        if issubclass(param.annotation, (list, Count)):
            return singularize(_name_or_flag(param))
    except TypeError:
        pass
    return _name_or_flag(param)
Esempio n. 58
0
def find_related_fields_to_rename(fields, prefix=[]):
    """
    Find all related fields on a Serializer or NestedBoundField.
    Args:
        fields: an object whose `.__iter__()` method returns instances of
            `BoundField` (e.g. a `Serializer` or `NestedBoundField`)
        prefix: a list of parent keys that map to the current list of
            fields.  (e.g. `{'one': {'two': {'three': 'value'}}}` will have
                `prefix=['one', 'two'] when `{'three': 'value'})` is passed
                into the function.
    Returns:
        list: list of RelatedFieldRename instances.
    """
    ret = []
    if isinstance(fields, ListSerializer):
        fields = fields.child.__class__()

    # this is selfish hack to support something I am doing
    # hopefully I can factor this out soon
    if isinstance(fields, BoundField):
        fields = fields._field

    # iterate over each field to determine if it is related
    for field in fields:
        assert isinstance(field, BoundField), (
            'Fields must be an iterator that returns `BoundField` instances.'
        )
        key = prefix + field.name.split('.')
        # iterate over any nested lists
        if field._proxy_class is ListSerializer:
            ret.extend(
                find_related_fields_to_rename(field.child, prefix=key)
            )
        # any nested dicts should be iterated over
        # this could check if `field` is an instance of `NestedBoundField`
        # but that would break my hack above
        elif hasattr(field, 'fields'):
            ret.extend(find_related_fields_to_rename(field, prefix=key))
        # the field is a list of pks and should be renamed
        elif field._proxy_class is ManyRelatedField:
            new_name = singularize(key[-1]) + '_ids'
            ret.append(RelatedFieldRename(key, new_name))
        # the field is a single pk and should be renamed
        elif field._proxy_class is PrimaryKeyRelatedField:
            new_name = key[-1] + '_id'
            ret.append(RelatedFieldRename(key, new_name))
    return ret
Esempio n. 59
0
def is_match_splabel(labels, label_to_trace, target_list, gt):

    # all matched gt words
    all_gt_words = []
    for ll in gt:
        for l in ll:
            if not l.find('none') >= 0:
                gt_word = inflection.singularize(l.split('-')[-1])
                all_gt_words += [gt_word]

    
    for label in labels:
        is_correct = is_label_correct(label, label_to_trace, target_list, all_gt_words)
        if is_correct:
            return True

    return False
Esempio n. 60
0
def stemming(word):

    # if word in be_words:
    #     return 'be'

    # try:
    #     if en.is_noun(word):
    #         word = en.noun.singular(word)
    #     elif en.is_adjective(word) or en.is_adverb(word):
    #         return word
    #     else:
    #         word = en.verb.present(word)
    # except Exception:
    #     pass
    # return en.spelling.correct(word)
    
    word = inflection.singularize(word)
    return word