示例#1
0
 def save(self, verbose=True):
     num_created = 0
     for feature in self.layer:
         parent_id = None
         if not self.skip_feature(feature):
             for block_fields in self.gen_blocks(feature):
                 block = Block(**block_fields)
                 block.geom = feature.geom.geos
                 street_name, block_name = make_pretty_name(
                     block_fields['left_from_num'],
                     block_fields['left_to_num'],
                     block_fields['right_from_num'],
                     block_fields['right_to_num'], block_fields['predir'],
                     block_fields['street'], block_fields['suffix'],
                     block_fields['postdir'])
                 block.pretty_name = block_name
                 block.street_pretty_name = street_name
                 block.street_slug = slugify(' '.join(
                     (block_fields['street'], block_fields['suffix'])))
                 block.save()
                 if parent_id is None:
                     parent_id = block.id
                 else:
                     block.parent_id = parent_id
                     block.save()
                 num_created += 1
                 if verbose:
                     print 'Created block %s' % block
     return num_created
示例#2
0
    def save(self, verbose=True):
        num_created = 0
        for feature in self.layer:
            parent_id = None
            if not self.skip_feature(feature):
                for block_fields in self.gen_blocks(feature):
                    # Usually (at least in Boston data) there is only
                    # 1 block per feature.  But sometimes there are
                    # multiple names for one street, eg.
                    # "N. Commercial Wharf" and "Commercial Wharf N.";
                    # in that case those would be yielded by gen_blocks() as
                    # two separate blocks. Is that intentional, or a bug?
                    block = Block(**block_fields)
                    block.geom = feature.geom.geos
                    (block.from_num, block.to_num) = make_block_numbers(
                        block_fields['left_from_num'],
                        block_fields['left_to_num'],
                        block_fields['right_from_num'],
                        block_fields['right_to_num'])

                    street_name, block_name = make_pretty_name(
                        block_fields['left_from_num'],
                        block_fields['left_to_num'],
                        block_fields['right_from_num'],
                        block_fields['right_to_num'],
                        block_fields['predir'],
                        block_fields['street'],
                        block_fields['suffix'],
                        block_fields['postdir']
                    )
                    block.pretty_name = block_name
                    block.street_pretty_name = street_name
                    block.street_slug = slugify(' '.join((block_fields['street'], block_fields['suffix'])))
                    block.save()
                    if parent_id is None:
                        parent_id = block.id
                    else:
                        block.parent_id = parent_id
                        block.save()
                    num_created += 1
                    if verbose:
                        print '%d\tCreated block %s for feature %d' % (num_created, block, feature.get('TLID'))
        return num_created
示例#3
0
    def save(self):
        alt_names_suff = (u'', u'1', u'2', u'3', u'4', u'5')
        num_created = 0
        for i, feature in enumerate(self.layer):
            if not self.fcc_pat.search(feature.get('FCC')):
                continue
            parent_id = None
            fields = {}
            for esri_fieldname, block_fieldname in FIELD_MAP.items():
                value = feature.get(esri_fieldname)
                if isinstance(value, basestring):
                    value = value.upper()
                elif isinstance(value, int) and value == 0:
                    value = None
                fields[block_fieldname] = value
            if not ((fields['left_from_num'] and fields['left_to_num']) or
                    (fields['right_from_num'] and fields['right_to_num'])):
                continue
            # Sometimes the "from" number is greater than the "to"
            # number in the source data, so we swap them into proper
            # ordering
            for side in ('left', 'right'):
                from_key, to_key = '%s_from_num' % side, '%s_to_num' % side
                if fields[from_key] > fields[to_key]:
                    fields[from_key], fields[to_key] = fields[to_key], fields[
                        from_key]
            if feature.geom.geom_name != 'LINESTRING':
                continue
            for suffix in alt_names_suff:
                name_fields = {}
                for esri_fieldname, block_fieldname in NAME_FIELD_MAP.items():
                    key = esri_fieldname + suffix
                    name_fields[block_fieldname] = feature.get(key).upper()
                if not name_fields['street']:
                    continue
                # Skip blocks with bare number street names and no suffix / type
                if not name_fields['suffix'] and re.search(
                        '^\d+$', name_fields['street']):
                    continue
                fields.update(name_fields)

                # Ensure we have unicode.
                for key, val in fields.items():
                    if isinstance(val, str):
                        fields[key] = val.decode(self.encoding)

                fields['street_pretty_name'], fields[
                    'pretty_name'] = make_pretty_name(
                        fields['left_from_num'],
                        fields['left_to_num'],
                        fields['right_from_num'],
                        fields['right_to_num'],
                        fields['predir'],
                        fields['street'],
                        fields['suffix'],
                        fields['postdir'],
                    )

                #print >> sys.stderr, 'Looking at block pretty name %s' % fields['street']

                fields['street_slug'] = slugify(u' '.join(
                    (fields['street'], fields['suffix'])))

                # Watch out for addresses like '247B' which can't be
                # saved as an IntegerField. But do this after making
                # pretty names.
                for addr_key in ('left_from_num', 'left_to_num',
                                 'right_from_num', 'right_to_num'):
                    fields[addr_key] = fields[addr_key].rstrip(string.letters)

                fields['from_num'], fields['to_num'] = make_block_numbers(
                    fields['left_from_num'], fields['left_to_num'],
                    fields['right_from_num'], fields['right_to_num'])

                block = Block(**fields)
                block.geom = feature.geom.geos
                self.log(u'Looking at block %s' % fields['street'])

                block.save()
                if parent_id is None:
                    parent_id = block.id
                else:
                    block.parent_id = parent_id
                    block.save()
                num_created += 1
                self.log('Created block %s' % block)
        return num_created
    def save(self):
        alt_names_suff = (u'', u'1', u'2', u'3', u'4', u'5')
        num_created = 0
        for i, feature in enumerate(self.layer):

            #if not self.fcc_pat.search(feature.get('FCC')):

             #   continue
            parent_id = None
            fields = {}
            for esri_fieldname, block_fieldname in FIELD_MAP.items():
                value = feature.get(esri_fieldname)
                if isinstance(value, basestring):
                    value = value.upper()
                elif isinstance(value, int) and value == 0:
                    value = None
                fields[block_fieldname] = value
            if not ((fields['left_from_num'] and fields['left_to_num']) or
                    (fields['right_from_num'] and fields['right_to_num'])):
                continue
            # Sometimes the "from" number is greater than the "to"
            # number in the source data, so we swap them into proper
            # ordering
            for side in ('left', 'right'):
                from_key, to_key = '%s_from_num' % side, '%s_to_num' % side
                if fields[from_key] > fields[to_key]:
                    fields[from_key], fields[to_key] = fields[to_key], fields[from_key]
            if feature.geom.geom_name != 'LINESTRING':
                continue
            #for suffix in alt_names_suff:
            name_fields = {}
            for esri_fieldname, block_fieldname in NAME_FIELD_MAP.items():
                key = esri_fieldname #+ suffix
                name_fields[block_fieldname] = feature.get(key).upper()
            if not name_fields['street']:
                continue
            # Skip blocks with bare number street names and no suffix / type
            if not name_fields['suffix'] and re.search('^\d+$', name_fields['street']):
                continue
            fields.update(name_fields)

            # Ensure we have unicode.
            for key, val in fields.items():
                if isinstance(val, str):
                    fields[key] = val.decode(self.encoding)

            fields['street_pretty_name'], fields['pretty_name'] = make_pretty_name(
                fields['left_from_num'],
                fields['left_to_num'],
                fields['right_from_num'],
                fields['right_to_num'],
                fields['predir'],
                fields['street'],
                fields['suffix'],
                fields['postdir'],
            )

            print >> sys.stderr, 'Looking at block pretty name %s' % fields['street']

            fields['street_slug'] = slugify(u' '.join((fields['street'], fields['suffix'])))

            # Watch out for addresses like '247B' which can't be
            # saved as an IntegerField. But do this after making
            # pretty names.
            for addr_key in ('left_from_num', 'left_to_num', 'right_from_num', 'right_to_num'):
                fields[addr_key] = fields[addr_key].rstrip(string.letters)

            fields['from_num'], fields['to_num'] = make_block_numbers(
                fields['left_from_num'],
                fields['left_to_num'],
                fields['right_from_num'],
                fields['right_to_num'])

            block = Block(**fields)
            block.geom = feature.geom.geos
            self.log(u'Looking at block %s' % fields['street'])


            block.save()
            if parent_id is None:
                parent_id = block.id
            else:
                block.parent_id = parent_id
                block.save()
            num_created += 1
            self.log('Created block %s' % block)
        return num_created
示例#5
0
 def save(self, verbose=False):
     alt_names_suff = ('', '1', '2', '3', '4', '5')
     num_created = 0
     for i, feature in enumerate(self.layer):
         if not self.fcc_pat.search(feature.get('FCC')):
             continue
         parent_id = None
         fields = {}
         for esri_fieldname, block_fieldname in FIELD_MAP.items():
             value = feature.get(esri_fieldname)
             if isinstance(value, basestring):
                 value = value.upper()
             elif isinstance(value, int) and value == 0:
                 value = None
             fields[block_fieldname] = value
         if not ((fields['left_from_num'] and fields['left_to_num']) or
                 (fields['right_from_num'] and fields['right_to_num'])):
             continue
         # Sometimes the "from" number is greater than the "to"
         # number in the source data, so we swap them into proper
         # ordering
         for side in ('left', 'right'):
             from_key, to_key = '%s_from_num' % side, '%s_to_num' % side
             if fields[from_key] > fields[to_key]:
                 fields[from_key], fields[to_key] = fields[to_key], fields[from_key]
         if feature.geom.geom_name != 'LINESTRING':
             continue
         for suffix in alt_names_suff:
             name_fields = {}
             for esri_fieldname, block_fieldname in NAME_FIELD_MAP.items():
                 key = esri_fieldname + suffix
                 name_fields[block_fieldname] = feature.get(key).upper()
             if not name_fields['street']:
                 continue
             # Skip blocks with bare number street names and no suffix / type
             if not name_fields['suffix'] and re.search('^\d+$', name_fields['street']):
                 continue
             fields.update(name_fields)
             block = Block(**fields)
             block.geom = feature.geom.geos
             street_name, block_name = make_pretty_name(
                 fields['left_from_num'],
                 fields['left_to_num'],
                 fields['right_from_num'],
                 fields['right_to_num'],
                 fields['predir'],
                 fields['street'],
                 fields['suffix'],
                 fields['postdir']
             )
             block.pretty_name = block_name
             block.street_pretty_name = street_name
             block.street_slug = slugify(' '.join((fields['street'], fields['suffix'])))
             block.save()
             if parent_id is None:
                 parent_id = block.id
             else:
                 block.parent_id = parent_id
                 block.save()
             num_created += 1
             if verbose:
                 print >> sys.stderr, 'Created block %s' % block
     return num_created