165 lines
7.0 KiB
Python
165 lines
7.0 KiB
Python
import random
|
|
import six
|
|
|
|
from geodata.addresses.config import address_config
|
|
|
|
from geodata.addresses.numbering import NumberedComponent, sample_alphabet, latin_alphabet
|
|
from geodata.encoding import safe_decode
|
|
from geodata.math.sampling import weighted_choice, zipfian_distribution, cdf
|
|
from geodata.numbers.spellout import numeric_expressions
|
|
|
|
|
|
class Floor(NumberedComponent):
|
|
# When we don't know the number of floors, use a Zipfian distribution
|
|
# to choose randomly between 1 and max_floors with 1 being much more
|
|
# likely than 2, etc.
|
|
max_floors = 10
|
|
max_basements = 2
|
|
numbered_floors = range(max_floors + 1) + range(-1, -max_basements - 1, -1)
|
|
floor_probs = zipfian_distribution(len(numbered_floors), 0.75)
|
|
floor_probs_cdf = cdf(floor_probs)
|
|
|
|
# For use with letters e.g. A0 is probably not as common
|
|
floors_letters = range(1, max_floors + 1) + [0]
|
|
floors_letters_probs = zipfian_distribution(len(floors_letters), 2.0)
|
|
floors_letters_cdf = cdf(floors_letters_probs)
|
|
|
|
@classmethod
|
|
def sample_floors(cls, num_floors, num_basements=0):
|
|
num_floors = int(num_floors)
|
|
return random.randint(-num_basements, (num_floors - 1) if num_floors > 0 else 0)
|
|
|
|
@classmethod
|
|
def sample_floors_range(cls, min_floor, max_floor):
|
|
return random.randint(min_floor, (max_floor - 1) if max_floor > min_floor else min_floor)
|
|
|
|
@classmethod
|
|
def random_int(cls, language, country=None, num_floors=None, num_basements=None):
|
|
number = None
|
|
if num_floors is not None:
|
|
try:
|
|
num_floors = int(num_floors)
|
|
except (ValueError, TypeError):
|
|
return weighted_choice(cls.numbered_floors, cls.floor_probs_cdf)
|
|
|
|
if num_floors <= cls.max_floors:
|
|
number = cls.sample_floors(num_floors, num_basements=num_basements or 0)
|
|
else:
|
|
number = cls.sample_floors_range(cls.max_floors + 1, num_floors)
|
|
|
|
else:
|
|
number = weighted_choice(cls.numbered_floors, cls.floor_probs_cdf)
|
|
|
|
return number
|
|
|
|
@classmethod
|
|
def random_from_int(cls, number, language, country=None):
|
|
num_type, num_type_props = cls.choose_alphanumeric_type('levels.alphanumeric', language, country=country)
|
|
if num_type is None:
|
|
return None
|
|
|
|
numbering_starts_at = int(address_config.get_property('levels.numbering_starts_at', language, country=country, default=0))
|
|
|
|
if number >= 0:
|
|
number += numbering_starts_at
|
|
|
|
if num_type == cls.NUMERIC:
|
|
return safe_decode(number)
|
|
elif num_type == cls.ROMAN_NUMERAL:
|
|
roman_numeral = numeric_expressions.roman_numeral(number)
|
|
if roman_numeral is not None:
|
|
return roman_numeral
|
|
else:
|
|
return safe_decode(number)
|
|
elif num_type == cls.HYPHENATED_NUMBER:
|
|
number2 = number + sample_floors_range(1, cls.max_floors)
|
|
return u'{}-{}'.format(number, number2)
|
|
else:
|
|
alphabet = address_config.get_property('alphabet', language, country=country, default=latin_alphabet)
|
|
alphabet_probability = address_config.get_property('alphabet_probability', language, country=country, default=None)
|
|
if alphabet_probability is not None and random.random() >= alphabet_probability:
|
|
alphabet = latin_alphabet
|
|
letter = sample_alphabet(alphabet)
|
|
if num_type == cls.ALPHA:
|
|
return letter
|
|
else:
|
|
number = weighted_choice(cls.floors_letters, cls.floors_letters_cdf)
|
|
|
|
if num_type == cls.ALPHA_PLUS_NUMERIC:
|
|
return six.u('{}{}').format(letter, number)
|
|
elif num_type == cls.NUMERIC_PLUS_ALPHA:
|
|
return six.u('{}{}').format(number, letter)
|
|
|
|
return None
|
|
|
|
@classmethod
|
|
def random(cls, language, country=None, num_floors=None, num_basements=None):
|
|
number = cls.random_int(language, country=country, num_floors=num_floors, num_basements=num_basements)
|
|
return cls.random_from_int(number, language, country=country)
|
|
|
|
@classmethod
|
|
def phrase(cls, floor, language, country=None, num_floors=None):
|
|
if floor is None:
|
|
return None
|
|
|
|
integer_floor = False
|
|
floor = safe_decode(floor)
|
|
try:
|
|
floor = int(floor)
|
|
integer_floor = True
|
|
except (ValueError, TypeError):
|
|
try:
|
|
floor = float(floor)
|
|
integer_floor = int(floor) == floor
|
|
except (ValueError, TypeError):
|
|
return cls.numeric_phrase('levels.alphanumeric', floor, language,
|
|
dictionaries=['level_types_numbered'], country=country)
|
|
|
|
numbering_starts_at = int(address_config.get_property('levels.numbering_starts_at', language, country=country, default=0))
|
|
try:
|
|
num_floors = int(num_floors)
|
|
top_floor = num_floors if numbering_starts_at == 1 else num_floors - 1
|
|
is_top = num_floors and floor == top_floor
|
|
except (ValueError, TypeError):
|
|
is_top = False
|
|
|
|
alias_prefix = 'levels.aliases'
|
|
aliases = address_config.get_property(alias_prefix, language, country=country)
|
|
if aliases:
|
|
alias = None
|
|
|
|
if not integer_floor and floor >= 0 and 'half_floors' in aliases:
|
|
floor = int(floor)
|
|
alias = 'half_floors'
|
|
elif not integer_floor and floor < 0 and 'half_floors_negative' in aliases:
|
|
floor = int(floor)
|
|
alias = 'half_floors_negative'
|
|
elif floor < -1 and '<-1' in aliases:
|
|
alias = '<-1'
|
|
elif is_top and 'top' in aliases:
|
|
alias = 'top'
|
|
elif safe_decode(floor) in aliases:
|
|
alias = safe_decode(floor)
|
|
|
|
floor = safe_decode(floor)
|
|
|
|
if alias:
|
|
alias_props = aliases.get(alias)
|
|
|
|
# Aliases upon aliases, e.g. for something like "Upper Mezzanine"
|
|
# where it's an alias for "1" under the half_floors key
|
|
if safe_decode(floor) in alias_props.get('aliases', {}):
|
|
alias_prefix = '{}.{}.aliases'.format(alias_prefix, alias)
|
|
alias = safe_decode(floor)
|
|
|
|
if alias:
|
|
return cls.numeric_phrase('{}.{}'.format(alias_prefix, alias), floor, language,
|
|
dictionaries=['level_types_basement',
|
|
'level_types_mezzanine',
|
|
'level_types_numbered',
|
|
'level_types_standalone',
|
|
'level_types_sub_basement'],
|
|
country=country)
|
|
|
|
return cls.numeric_phrase('levels.alphanumeric', floor, language,
|
|
dictionaries=['level_types_numbered'], country=country) |