def _create_building(self, orientation): WELL_OUTER = (Vec3(0,0,0), Vec3(-5,0,-5)) WELL_CORE = (Vec3(-1,0,-1), Vec3(-4,0,-4)) WELL_INNER = (Vec3(-2,0,-2), Vec3(-3,0,-3)) WELL_WIDTH = 6 WELL_BASE = [] WELL_BASE.append(BuildingBlock(WELL_CORE[0], block.COBBLESTONE, WELL_CORE[1])) WELL_WATER = [] WELL_WATER.append(BuildingBlock(WELL_CORE[0], block.COBBLESTONE, WELL_CORE[1])) WELL_WATER.append(BuildingBlock(WELL_INNER[0], block.WATER, WELL_INNER[1])) WELL_GROUND = [] WELL_GROUND.append(BuildingBlock(WELL_OUTER[0], block.GRAVEL, WELL_OUTER[1])) WELL_GROUND.append(BuildingBlock(WELL_CORE[0], block.COBBLESTONE, WELL_CORE[1])) WELL_GROUND.append(BuildingBlock(WELL_INNER[0], block.WATER, WELL_INNER[1])) WELL_WALLS = [] WELL_WALLS.append(BuildingBlock(WELL_CORE[0], block.COBBLESTONE, WELL_CORE[1])) WELL_WALLS.append(BuildingBlock(WELL_INNER[0], block.AIR, WELL_INNER[1])) WELL_SUPPORT = [] WELL_SUPPORT.append(BuildingBlock(Vec3(-1,0,-1), block.FENCE)) WELL_SUPPORT.append(BuildingBlock(Vec3(-1,0,-4), block.FENCE)) WELL_SUPPORT.append(BuildingBlock(Vec3(-4,0,-4), block.FENCE)) WELL_SUPPORT.append(BuildingBlock(Vec3(-4,0,-1), block.FENCE)) bl = Building(orientation, WELL_WIDTH) bl.layers.append(BuildingLayer(WELL_BASE, -3)) bl.layers.append(BuildingLayer(WELL_WATER, -2)) bl.layers.append(BuildingLayer(WELL_GROUND, -1)) bl.layers.append(BuildingLayer(WELL_WALLS, 0)) bl.layers.append(BuildingLayer(WELL_SUPPORT, 1)) bl.layers.append(BuildingLayer(WELL_SUPPORT, 2)) bl.layers.append(BuildingLayer(WELL_BASE, 3)) # set_direction needs to be called after adding layers to building bl._set_orientation() # rotate offset for test: if orientation == Building.EAST: self.default_offset.rotateRight() elif orientation == Building.SOUTH: self.default_offset.rotateRight() self.default_offset.rotateRight() elif orientation == Building.WEST: self.default_offset.rotateLeft() return bl
def save_load_events(self):
for e in pygame.event.get():
# quitter le jeu de force
if e.type == pygame.QUIT:
self.run = False
pygame.quit()
# récupérer les coordonnées de clic de la souris
if e.type == pygame.MOUSEBUTTONDOWN:
x = pygame.mouse.get_pos()[0]
# False to save and True to load
if x < self.bg.w / 2:
self.s_l_choice = False
else:
self.s_l_choice = True
# vérification du point de relâchement du clic de la souris
if e.type == pygame.MOUSEBUTTONUP:
x = pygame.mouse.get_pos()[0]
# charger les données de sauvegarde
if self.s_l_choice and x > self.bg.w / 2:
infos = decoding()
print(infos)
self.buildings.empty()
self.gold.quantity, self.stuff.quantity = infos[0]
self.gold.add(0)
self.stuff.add(0)
self.bg.x, self.bg.y, self.bg.zoom = infos[1]
for b in infos[2]:
type = self.dict_loading[b[0][0]]
image = self.pictures[type]
batiment = Building(image, b[1], b[2], self.bg, type)
self.buildings.add(batiment)
self.s_l = False
self.win.fill((0, 0, 0))
# sauvegarder les données de sauvegarde
elif not self.s_l_choice and x < self.bg.w / 2:
resources = [self.gold.quantity, self.stuff.quantity]
building = []
for b in self.buildings:
building.append([b.type, b.gap_x, b.gap_y])
data = [
resources, [self.bg.x, self.bg.y, self.bg.zoom],
building
]
encode(data)
self.s_l = False
self.win.fill((0, 0, 0))
# si la touche escape est pressée, le menu save/load est fermé
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_ESCAPE:
self.s_l = False
self.win.fill((0, 0, 0))
def run_game():
#游戏初始化，创建一个屏幕对象
pygame.init()
g_settings = Settings()
screen = pygame.display.set_mode((g_settings.screen_width,g_settings.screen_height),pygame.RESIZABLE)
pygame.display.set_caption("Flappy Bird")
bird = Bird(g_settings,screen)
building = Building(g_settings, screen)
building1 = Building(g_settings, screen)
building1.rect1.x = building1.rect1.x + 200
building1.rect2.x = building1.rect2.x + 200
building2 = Building(g_settings, screen)
building2.rect1.x = building1.rect1.x + 400
building2.rect2.x = building1.rect2.x + 400
building3 = Building(g_settings, screen)
building3.rect1.x = building1.rect1.x + 600
building3.rect2.x = building1.rect2.x + 600
building4 = Building(g_settings, screen)
building4.rect1.x = building1.rect1.x + 800
building4.rect2.x = building1.rect2.x + 800
while True:
# 监测键盘事件和鼠标事件
gf.check_events(bird)
#屏幕刷新相关函数
gf.update_screen(screen,g_settings,bird,building,building1,building2,building3,building4)
def handle_build_action(self, civ, action):
"""Handle incoming build actions and update game state."""
if self._civs[civ].id != action.unit._civ_id:
return ([], ServerError(4))
building_type = action.building_type
tile = self.validate_tile(action.unit.position)
unit = self.validate_unit(civ, action.unit)
bld_id = database_API.Building.insert(self._session,
self._civs[civ]._id,
True, Building.get_type
(building_type),
tile.x, tile.y, tile.z)
self._civs[civ].build_structure(unit,
building_type,
bld_id)
return ([tile], bld_id)
def get_buildings_from_file():
d = pd.read_excel("building_data.xlsx",
sheet_name="Sheet1",
names=[
"date_added", "occupancy", "lease_signed",
"building", "building_class", "city", "deal_size",
"tenant", "new_renewal_expansion", "term",
"base_rent", "rent_structure", "esc", "t_i",
"rent_abatement", "tenant_broker", "ll_broker",
"t_o", "comments"
])
od = d.where((pd.notnull(d)), None).to_dict(orient="index",
into=OrderedDict)
buildings = []
for i in range(len(od)):
building = Building(**od[i])
buildings.append(building)
return buildings
def renderBuilding(self, screen):
# отрисовка окружения поля
for y in range(self.size[1]):
for x in range(self.size[0]):
# строения
if self.building[x][y].type != Type(
).void and self.building[x][y].type != Type().road:
image = self.imageBuilding[self.building[x][y].type -
1][self.building[x][y].team - 1]
rect = (int(x * self.plates_size[0]) + self.sideShift,
int(y * self.plates_size[1]))
screen.blit(image, rect)
# дорога
elif self.building[x][y].type == Type().road:
# матрица с ситуацией на поле
piece = [[False, False, False], [False, True, False],
[False, False, False]]
try:
if self.building[x][y - 1].type == Type().road:
piece[0][1] = True
except:
pass
try:
if self.building[x - 1][y].type == Type().road:
piece[1][0] = True
except:
pass
try:
if self.building[x + 1][y].type == Type().road:
piece[1][2] = True
except:
pass
try:
if self.building[x][y + 1].type == Type().road:
piece[2][1] = True
except:
pass
# принимаем тип дороги
rect = (int(x * self.plates_size[0]) + self.sideShift,
int(y * self.plates_size[1]))
screen.blit(
self.imageRoad[Building().indexOfRoadPiece(piece)],
rect)
def init(cls):
pygame.init()
cls.buildings.add(Building(-100, 0, 100, cls.height, 1, 1))
cls.buildings.add(Building(0, 280, 100, 200, 5, 5))
cls.buildings.add(Building(100, 380, 200, 100, 5, 3))
cls.buildings.add(Building(300, 330, 150, 150, 10, 10))
cls.buildings.add(Building(450, 200, 190, 280, 10, 8))
cls.buildings.add(Building(cls.width, 0, cls.width+100, cls.height, 1, 1))
cls.player1 = Gorilla(50,50)
cls.player1.set_vel(10,10)
cls.player2 = Gorilla(cls.width-50-50,50)
cls.players.add(cls.player1)
cls.players.add(cls.player2)
cls.curr_player = cls.player1
def run_game():
#游戏初始化，创建一个屏幕对象
pygame.init()
g_settings = Settings()
screen = pygame.display.set_mode((g_settings.screen_width,g_settings.screen_height),pygame.RESIZABLE)
pygame.display.set_caption("Flappy Bird")
bird = Bird(g_settings,screen)
building = Building(g_settings, screen)
while True:
# 监测键盘事件和鼠标事件
gf.check_events(bird)
#屏幕刷新相关函数
gf.update_screen(screen,g_settings,bird,building)
def nextState(self, building_proj, mrow, mcol):
new_map = deepcopy(self.map)
new_buildings = deepcopy(self.buildings)
building_id = len(self.buildings) + 1
new_buildings.append(Building(building_proj, mrow, mcol, building_id))
for prow in range(building_proj.rows):
for pcol in range(building_proj.cols):
if building_proj.plan[prow][pcol] == '#':
if mrow + prow >= len(new_map) or mcol + pcol >= len(
new_map[mrow + prow]):
return False
if new_map[mrow + prow][mcol + pcol] == '.':
new_map[mrow + prow][mcol + pcol] = building_id
else:
return False
new_score = self.calculateScore(self.city.walk_dist, self.score,
self.map, building_proj, mrow, mcol,
new_buildings)
new_buildings[-1].score = new_score - self.score
return State(self.city, new_buildings, new_map, new_score)
def framePaint(self, event):
# When called for the first time, instantiates player and 3 buildings
if self.buildings == None:
self.buildings = [Building(self.frame) for x in range(3)]
if self.player == None:
self.player = Bruin(self.frame)
# Constructs painter for the central frame
painter = QtGui.QPainter(self.frame)
# Sets focus on self whenever focus is True
if self.focus:
self.setFocus()
else:
self.focus = True
# If active, calls paintBuilding and paintBruin functions
if self.active:
painter.drawImage(
5, 5,
self.graphic.scaled(self.frame.geometry().width() - 10,
self.frame.geometry().height() - 10))
for b in self.buildings:
b.paintBuilding(painter)
self.player.paintBruin(painter)
def load_buildings(self, filename):
"""" Load building parameters """
buildings = []
with open(filename) as json_file:
data = json.load(json_file)
for s in data['buildings']:
k = s.keys()
for i in k:
t = s[i]
name = t['name']
value = t['value']
width = t['width']
length = t['length']
extra = t['extra']
bonus = t['bonus']
buildings.append(
Building(name, value, width, length, extra, bonus))
return buildings
def __init__(self, x, y, node_type):
Location.__init__(self, x, y)
self.important = False
if node_type == 'N' or node_type == 'M':
self.owner = PlayerColor.NEUTRAL
self.building = Building(BuildingType.EMPTY, UnitType.EMPTY)
self.important = node_type == 'M'
elif node_type == 'B':
self.owner = PlayerColor.BLUE
self.building = Building(BuildingType.HOME, UnitType.PIKEMAN)
self.important = True
elif node_type == 'R':
self.owner = PlayerColor.RED
self.building = Building(BuildingType.HOME, UnitType.PIKEMAN)
self.important = True
self.spawn_timer = 0
self.exit_direction = {PlayerColor.RED: None, PlayerColor.BLUE: None}
self.unit_in_loc = self.unit_in_loc
def update(self, keys):
self.message = "" # clear any previous message
for control in self.controls:
if keys[control]:
if self.controls[control][0] == "move":
#self.rect.move_ip(self.controls[control][1])
self.move(self.controls[control][1])
if self.controls[control][0] == "speed":
self.changeSpeed(self.controls[control][1])
if self.controls[control][0] == "place":
newBuilding = Building(FACTORY_FILENAME, (self.rect.centerx, GROUND))
# check if there is room to place new factory
if pg.sprite.spritecollide(newBuilding, BUILDINGS, False):
self.message = "No room!"
else:
BUILDINGS.add(newBuilding)
ALL_SPRITES.add(newBuilding, layer=1) # buildings = layer 1
vector = self.target - self.pos
move_length = vector.length()
if move_length < self.speed:
self.pos = self.target
self.autoMoving = False
elif move_length != 0:
vector.normalize_ip()
vector = vector * self.speed
self.pos += vector
else:
self.autoMoving = False
self.rect.topleft = list(int(v) for v in self.pos)
self.updateCam()
def setup(self):
settings = {
'bot_name': 'unittest',
'email': '*****@*****.**',
'registration_id': 'test_123'
}
self.building = Building('training_1', settings)
self.building.floors = 10
state = {
'elevators': [
{
'id': 0,
'floor': 0
},
{
'id': 1,
'floor': 0
}
],
'floors': 10
}
self.building.build_elevators(state)
def building_name(code):
for cc in buildings.buildings:
if code == cc['code']:
return cc['name']
def tropp_name(code):
for tr in troops.troops:
if code == tr['code']:
return tr['name']
if __name__ == '__main__':
print("Hi everyone!")
buildings = Building()
troops = Troop()
while True:
nickname1 = input("Player1 please enter your nickname: ")
if len(nickname1) == 0:
continue
else:
break
while True:
nickname2 = input("Player2 please enter your nickname: ")
if len(nickname2) == 0:
continue
else:
break
player1 = Player(nickname1, 50000)
player2 = Player(nickname2, 50000)
# 1) В началото създаваме сградите, които искаме да продаваме
# 2) След това създаваме нашите брокери, които ще продават
# 3) И накрая създаваме компанията си, в която работят напите брокери
# -----------
# Всеки ден има различни брокери, които са на смяна. След като сме казали, кои искаме
# да са на смяна, добавяме и кои сгради искаме всеки един да продаде.
# При продаването на сградата има значение тя колко струва. В зависомост от това се
# трупат точки и нашите брокери получват бонус в края на смяната си.
#
from broker import Broker
from building import Building
from company import Company
# [Сгради] - Създаваме ОБЕКТИ за сградите (buildin_1, buildin_2....):
building_1 = Building("Arholl Arena", 7, 500601.71)
building_2 = Building("DSK Bank", 8, 3000000)
building_3 = Building("Maria's diner", 1, 5732.97)
building_4 = Building("Matt Hann",4, 4242)
building_5 = Building("Balkan Hotel", 6, 1500000.00)
building_6 = Building("Disko BG", 2, 430034)
# [Брокери] - създаваме ОБЕКТИ за брокерите (broker_1, broker_2...):
broker_1 = Broker("Natali", "45")
broker_2 = Broker("George", "27")
broker_3 = Broker("Jasmin", "30")
broker_4 = Broker("Stefan", "43")
#Създаваме ОБЕКТ company
company = Company("MATTAHAN")
# **************************** Challenge: Urban Planner II ****************************
"""
Author: Trinity Terry
pyrun: python main.py
"""
from building import Building
from city import City
from random_names import random_name
# Create a new city instance and add your building instances to it. Once all buildings are in the city, iterate the city's building collection and output the information about each building in the city.
megalopolis = City("Megalopolis", "Trinity", "2020")
buildings = [
Building("333 Commerce Street", 33),
Building("Strada General Traian Moșoiu 24", 5),
Building("5 Avenue Anatole France", 276),
Building("1600 Pennsylvania Ave NW", 6),
Building("48009 Bilbo", 3)
]
for building in buildings:
person = random_name()
building.purchase(person)
building.construct()
megalopolis.add_building(building)
megalopolis.print_building_details()
class Village:
def __init__(self):
self.hq = Building({
'level': 1,
'name': 'hq',
'maxLevel': 30, # 30,
'cost': [90, 80, 70, 5],
'costFactor': [1.26, 1.275, 1.26, 1.17],
'buildTime': 7 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 10,
'pointFactor': pointFactor,
})
self.woodMine = Building({
'level': 1,
'name': 'wm',
'maxLevel': 30, # 30,
'cost': [50, 60, 40, 5],
'costFactor': [1.25, 1.275, 1.245, 1.155],
'buildTime': 7 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 6,
'pointFactor': pointFactor,
'production': 30,
'productionFactor': productionFactor
})
self.clayMine = Building({
'level': 1,
'name': 'cm',
'maxLevel': 30, # 30,
'cost': [65, 50, 40, 10],
'costFactor': [1.27, 1.265, 1.24, 1.14],
'buildTime': 7 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 6,
'pointFactor': pointFactor,
'production': 30,
'productionFactor': productionFactor
})
self.ironMine = Building({
'level': 1,
'name': 'im',
'maxLevel': 30, # 30,
'cost': [75, 65, 70, 10],
'costFactor': [1.252, 1.275, 1.24, 1.17],
'buildTime': 9 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 6,
'pointFactor': pointFactor,
'production': 30,
'productionFactor': productionFactor
})
self.farm = Building({
'level': 1,
'name': 'fm',
'maxLevel': 30, # 30,
'cost': [45, 40, 30, 0],
'costFactor': [1.3, 1.32, 1.29, 1],
'buildTime': 10 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 5,
'pointFactor': pointFactor,
'population': 240,
'populationFactor': populationFactor
})
self.warehouse = Building({
'level': 1,
'name': 'wh',
'maxLevel': 30, # 30,
'cost': [60, 50, 40, 0],
'costFactor': [1.265, 1.27, 1.245, 1.15],
'buildTime': 8 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 6,
'pointFactor': pointFactor,
'capacity': 1000,
'capacityFactor': capacityFactor
})
self.barracks = Building({
'level': 0,
'name': 'br',
'maxLevel': 25, # 25,
'cost': [200, 170, 90, 7],
'costFactor': [1.26, 1.28, 1.26, 1.17],
'buildTime': 15 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 16,
'pointFactor': pointFactor
})
self.stable = Building({
'level': 0,
'name': 'sb',
'maxLevel': 20, # 20,
'cost': [270, 240, 260, 8],
'costFactor': [1.26, 1.28, 1.26, 1.17],
'buildTime': 50 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 20,
'pointFactor': pointFactor
})
self.garage = Building({
'level': 0,
'name': 'gr',
'maxLevel': 15,
'cost': [300, 240, 260, 8],
'costFactor': [1.26, 1.28, 1.26, 1.17],
'buildTime': 50 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 24,
'pointFactor': pointFactor
})
self.snob = Building({
'level': 0,
'name': 'SN',
'maxLevel': 1,
'cost': [15000, 25000, 10000, 80],
'costFactor': [2, 2, 2, 1.17],
'buildTime': 4890 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 512,
'pointFactor': pointFactor
})
self.smith = Building({
'level': 0,
'name': 'sm',
'maxLevel': 20,
'cost': [220, 180, 240, 20],
'costFactor': [1.26, 1.275, 1.26, 1.17],
'buildTime': 50 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 19,
'pointFactor': pointFactor
})
self.place = Building({
'level': 1,
'name': 'pl',
'maxLevel': 1,
'cost': [10, 40, 30, 0],
'costFactor': [1.26, 1.275, 1.26, 1.17],
'buildTime': 90 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 0,
'pointFactor': pointFactor
})
self.statue = Building({
'level': 0,
'name': 'st',
'maxLevel': 1,
'cost': [220, 220, 220, 10],
'costFactor': [1.26, 1.275, 1.26, 1.17],
'buildTime': 12 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 24,
'pointFactor': pointFactor
})
self.market = Building({
'level': 0,
'name': 'mk',
'maxLevel': 25,
'cost': [100, 100, 100, 20],
'costFactor': [1.26, 1.275, 1.26, 1.17],
'buildTime': 22 * 60 + 30,
'buildTimeFactor': buildTimeFactor,
'points': 10,
'pointFactor': pointFactor
})
self.hide = Building({
'level': 0,
'name': 'hd',
'maxLevel': 10,
'cost': [50, 60, 50, 2],
'costFactor': [1.25, 1.25, 1.25, 1.17],
'buildTime': 15 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 5,
'pointFactor': pointFactor
})
self.wall = Building({
'level': 0,
'name': 'wl',
'maxLevel': 20,
'cost': [50, 100, 20, 5],
'costFactor': [1.26, 1.275, 1.26, 1.17],
'buildTime': 30 * 60,
'buildTimeFactor': buildTimeFactor,
'points': 8,
'pointFactor': pointFactor
})
self.buildings = []
self.buildings += [self.hq]
self.buildings += [self.woodMine]
self.buildings += [self.clayMine]
self.buildings += [self.ironMine]
self.buildings += [self.farm]
self.buildings += [self.warehouse]
self.buildings += [self.barracks]
self.buildings += [self.stable]
self.buildings += [self.garage]
self.buildings += [self.snob]
self.buildings += [self.smith]
self.buildings += [self.place]
self.buildings += [self.statue]
self.buildings += [self.market]
self.buildings += [self.hide]
self.buildings += [self.wall]
def get_buildings(self):
return self.buildings
def get_wood_yield(self):
return self.woodMine.get_production()
def get_clay_yield(self):
return self.clayMine.get_production()
def get_iron_yield(self):
return self.ironMine.get_production()
def get_yield(self, i):
if i == 0:
return self.get_wood_yield()
elif i == 1:
return self.get_clay_yield()
elif i == 2:
return self.get_iron_yield()
def get_population(self):
return sum(map(lambda b: b.get_population(), self.buildings))
def get_pop_limit(self):
return self.farm.get_population()
def get_capacity(self):
return self.warehouse.get_capacity()
def readDOE(serialize_output=True):
"""
Read csv files of DOE buildings
Sheet 1 = BuildingSummary
Sheet 2 = ZoneSummary
Sheet 3 = LocationSummary
Sheet 4 = Schedules
Note BLD8 & 10 = school
Then make matrix of ref data as nested nested lists [16, 3, 16]:
matrix refDOE = Building objs
matrix Schedule = SchDef objs
matrix refBEM (16,3,16) = BEMDef
where:
[16,3,16] is Type = 1-16, Era = 1-3, climate zone = 1-16
i.e.
Type: FullServiceRestaurant, Era: Pre80, Zone: 6A Minneapolis
Nested tree:
[TYPE_1:
ERA_1:
CLIMATE_ZONE_1
...
CLIMATE_ZONE_16
ERA_2:
CLIMATE_ZONE_1
...
CLIMATE_ZONE_16
...
ERA_3:
CLIMATE_ZONE_1
...
CLIMATE_ZONE_16]
"""
#Nested, nested lists of Building, SchDef, BEMDef objects
refDOE = map(lambda j_: map(lambda k_: [None] * 16, [None] * 3),
[None] * 16) #refDOE(16,3,16) = Building;
Schedule = map(lambda j_: map(lambda k_: [None] * 16, [None] * 3),
[None] * 16) #Schedule (16,3,16) = SchDef;
refBEM = map(lambda j_: map(lambda k_: [None] * 16, [None] * 3),
[None] * 16) #refBEM (16,3,16) = BEMDef;
#Purpose: Loop through every DOE reference csv and extract building data
#Nested loop = 16 types, 3 era, 16 zones = time complexity O(n*m*k) = 768
for i in xrange(16):
#i = 16 types of buildings
#print "\tType: {} @i={}".format(BLDTYPE[i], i)
# Read building summary (Sheet 1)
file_doe_name_bld = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_BuildingSummary.csv".format(i + 1))
list_doe1 = read_csv(file_doe_name_bld)
#listof(listof 3 era values)
nFloor = str2fl(
list_doe1[3][3:6]
) # Number of Floors, this will be list of floats and str if "basement"
glazing = str2fl(list_doe1[4][3:6]) # [?] Total
hCeiling = str2fl(list_doe1[5][3:6]) # [m] Ceiling height
ver2hor = str2fl(list_doe1[7][3:6]) # Wall to Skin Ratio
AreaRoof = str2fl(
list_doe1[8][3:6]) # [m2] Gross Dimensions - Total area
# Read zone summary (Sheet 2)
file_doe_name_zone = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_ZoneSummary.csv".format(i + 1))
list_doe2 = read_csv(file_doe_name_zone)
#listof(listof 3 eras)
AreaFloor = str2fl([list_doe2[2][5], list_doe2[3][5],
list_doe2[4][5]]) # [m2]
Volume = str2fl([list_doe2[2][6], list_doe2[3][6],
list_doe2[4][6]]) # [m3]
AreaWall = str2fl([list_doe2[2][8], list_doe2[3][8],
list_doe2[4][8]]) # [m2]
AreaWindow = str2fl(
[list_doe2[2][9], list_doe2[3][9], list_doe2[4][9]]) # [m2]
Occupant = str2fl(
[list_doe2[2][11], list_doe2[3][11],
list_doe2[4][11]]) # Number of People
Light = str2fl([list_doe2[2][12], list_doe2[3][12],
list_doe2[4][12]]) # [W/m2]
Elec = str2fl([list_doe2[2][13], list_doe2[3][13],
list_doe2[4][13]]) # [W/m2] Electric Plug and Process
Gas = str2fl([list_doe2[2][14], list_doe2[3][14],
list_doe2[4][14]]) # [W/m2] Gas Plug and Process
SHW = str2fl([list_doe2[2][15], list_doe2[3][15],
list_doe2[4][15]]) # [Litres/hr] Peak Service Hot Water
Vent = str2fl([list_doe2[2][17], list_doe2[3][17],
list_doe2[4][17]]) # [L/s/m2] Ventilation
Infil = str2fl([list_doe2[2][20], list_doe2[3][20], list_doe2[4][20]
]) # Air Changes Per Hour (ACH) Infiltration
# Read location summary (Sheet 3)
file_doe_name_location = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_LocationSummary.csv".format(i + 1))
list_doe3 = read_csv(file_doe_name_location)
#(listof (listof 3 eras (listof 16 climate types)))
TypeWall = [
list_doe3[3][4:20], list_doe3[14][4:20], list_doe3[25][4:20]
] # Construction type
RvalWall = str2fl(
[list_doe3[4][4:20], list_doe3[15][4:20],
list_doe3[26][4:20]]) # [m2*K/W] R-value
TypeRoof = [
list_doe3[5][4:20], list_doe3[16][4:20], list_doe3[27][4:20]
] # Construction type
RvalRoof = str2fl(
[list_doe3[6][4:20], list_doe3[17][4:20],
list_doe3[28][4:20]]) # [m2*K/W] R-value
Uwindow = str2fl(
[list_doe3[7][4:20], list_doe3[18][4:20],
list_doe3[29][4:20]]) # [W/m2*K] U-factor
SHGC = str2fl(
[list_doe3[8][4:20], list_doe3[19][4:20],
list_doe3[30][4:20]]) # [-] coefficient
HVAC = str2fl(
[list_doe3[9][4:20], list_doe3[20][4:20],
list_doe3[31][4:20]]) # [kW] Air Conditioning
HEAT = str2fl(
[list_doe3[10][4:20], list_doe3[21][4:20],
list_doe3[32][4:20]]) # [kW] Heating
COP = str2fl(
[list_doe3[11][4:20], list_doe3[22][4:20],
list_doe3[33][4:20]]) # [-] Air Conditioning COP
EffHeat = str2fl(
[list_doe3[12][4:20], list_doe3[23][4:20],
list_doe3[34][4:20]]) # [%] Heating Efficiency
FanFlow = str2fl(
[list_doe3[13][4:20], list_doe3[24][4:20],
list_doe3[35][4:20]]) # [m3/s] Fan Max Flow Rate
# Read Schedules (Sheet 4)
file_doe_name_schedules = os.path.join(
"{}".format(DIR_DOE_PATH), "BLD{}".format(i + 1),
"BLD{}_Schedules.csv".format(i + 1))
list_doe4 = read_csv(file_doe_name_schedules)
#listof(listof weekday, sat, sun (list of 24 fractions)))
SchEquip = str2fl(
[list_doe4[1][6:30], list_doe4[2][6:30],
list_doe4[3][6:30]]) # Equipment Schedule 24 hrs
SchLight = str2fl(
[list_doe4[4][6:30], list_doe4[5][6:30],
list_doe4[6][6:30]]) # Light Schedule 24 hrs; Wkday=Sat=Sun=Hol
SchOcc = str2fl(
[list_doe4[7][6:30], list_doe4[8][6:30],
list_doe4[9][6:30]]) # Occupancy Schedule 24 hrs
SetCool = str2fl(
[list_doe4[10][6:30], list_doe4[11][6:30],
list_doe4[12][6:30]]) # Cooling Setpoint Schedule 24 hrs
SetHeat = str2fl([
list_doe4[13][6:30], list_doe4[14][6:30], list_doe4[15][6:30]
]) # Heating Setpoint Schedule 24 hrs; summer design
SchGas = str2fl(
[list_doe4[16][6:30], list_doe4[17][6:30],
list_doe4[18][6:30]]) # Gas Equipment Schedule 24 hrs; wkday=sat
SchSWH = str2fl(
[list_doe4[19][6:30], list_doe4[20][6:30], list_doe4[21][6:30]]
) # Solar Water Heating Schedule 24 hrs; wkday=summerdesign, sat=winterdesgin
for j in xrange(3):
# j = 3 built eras
#print"\tEra: {} @j={}".format(BUILTERA[j], j)
for k in xrange(16):
# k = 16 climate zones
#print "\tClimate zone: {} @k={}".format(ZONETYPE[k], k)
B = Building(
hCeiling[j], # floorHeight by era
1, # intHeatNight
1, # intHeatDay
0.1, # intHeatFRad
0.1, # intHeatFLat
Infil[j], # infil (ACH) by era
Vent[j] /
1000., # vent (m^3/s/m^2) by era, converted from liters
glazing[j], # glazing ratio by era
Uwindow[j][k], # uValue by era, by climate type
SHGC[j][k], # SHGC, by era, by climate type
'AIR', # cooling condensation system type: AIR, WATER
COP[j][k], # cop by era, climate type
297, # coolSetpointDay = 24 C
297, # coolSetpointNight
293, # heatSetpointDay = 20 C
293, # heatSetpointNight
(HVAC[j][k] * 1000.0) / AreaFloor[
j], # coolCap converted to W/m2 by era, climate type
EffHeat[j][k], # heatEff by era, climate type
293) # initialTemp at 20 C
#Not defined in the constructor
B.heatCap = (HEAT[j][k] * 1000.0) / AreaFloor[
j] # heating Capacity converted to W/m2 by era, climate type
B.Type = BLDTYPE[i]
B.Era = BUILTERA[j]
B.Zone = ZONETYPE[k]
refDOE[i][j][k] = B
# Define wall, mass(floor), roof
# Reference from E+ for conductivity, thickness (reference below)
# Material: (thermalCond, volHeat = specific heat * density)
Concrete = Material(1.311, 836.8 * 2240, "Concrete")
Insulation = Material(0.049, 836.8 * 265.0, "Insulation")
Gypsum = Material(0.16, 830.0 * 784.9, "Gypsum")
Wood = Material(0.11, 1210.0 * 544.62, "Wood")
Stucco = Material(0.6918, 837.0 * 1858.0, "Stucco")
# Wall (1 in stucco, concrete, insulation, gypsum)
# Check TypWall by era, by climate
if TypeWall[j][k] == "MassWall":
#Construct wall based on R value of Wall from refDOE and properties defined above
# 1" stucco, 8" concrete, tbd insulation, 1/2" gypsum
Rbase = 0.271087 # R val based on stucco, concrete, gypsum
Rins = RvalWall[j][k] - Rbase #find insulation value
D_ins = Rins * Insulation.thermalCond # depth of ins from m2*K/W * W/m*K = m
if D_ins > 0.01:
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, D_ins,
0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Insulation, Gypsum
]
else:
#if it's less then 1 cm don't include in layers
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, 0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Gypsum
]
wall = Element(0.08, 0.92, thickness, layers, 0., 293., 0.,
"MassWall")
# If mass wall, assume mass floor (4" concrete)
# Mass (assume 4" concrete);
alb = 0.2
emis = 0.9
thickness = [0.054, 0.054]
concrete = Material(1.31, 2240.0 * 836.8)
mass = Element(alb, emis, thickness, [concrete, concrete],
0, 293, 1, "MassFloor")
elif TypeWall[j][k] == "WoodFrame":
# 0.01m wood siding, tbd insulation, 1/2" gypsum
Rbase = 0.170284091 # based on wood siding, gypsum
Rins = RvalWall[j][k] - Rbase
D_ins = Rins * Insulation.thermalCond #depth of insulatino
if D_ins > 0.01:
thickness = [0.01, D_ins, 0.0127]
layers = [Wood, Insulation, Gypsum]
else:
thickness = [0.01, 0.0127]
layers = [Wood, Gypsum]
wall = Element(0.22, 0.92, thickness, layers, 0., 293., 0.,
"WoodFrameWall")
# If wood frame wall, assume wooden floor
alb = 0.2
emis = 0.9
thickness = [0.05, 0.05]
wood = Material(1.31, 2240.0 * 836.8)
mass = Element(alb, emis, thickness, [wood, wood], 0.,
293., 1., "WoodFloor")
elif TypeWall[j][k] == "SteelFrame":
# 1" stucco, 8" concrete, tbd insulation, 1/2" gypsum
Rbase = 0.271087 # based on stucco, concrete, gypsum
Rins = RvalWall[j][k] - Rbase
D_ins = Rins * Insulation.thermalCond
if D_ins > 0.01:
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, D_ins,
0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Insulation, Gypsum
]
else: # If insulation is too thin, assume no insulation
thickness = [
0.0254, 0.0508, 0.0508, 0.0508, 0.0508, 0.0127
]
layers = [
Stucco, Concrete, Concrete, Concrete, Concrete,
Gypsum
]
wall = Element(0.15, 0.92, thickness, layers, 0., 293., 0.,
"SteelFrame")
# If mass wall, assume mass foor
# Mass (assume 4" concrete),
alb = 0.2
emis = 0.93
thickness = [0.05, 0.05]
mass = Element(alb, emis, thickness, [Concrete, Concrete],
0., 293., 1., "MassFloor")
elif TypeWall[j][k] == "MetalWall":
# metal siding, insulation, 1/2" gypsum
alb = 0.2
emis = 0.9
D_ins = max(
(RvalWall[j][k] * Insulation.thermalCond) / 2, 0.01
) #use derived insul thickness or 0.01 based on max
thickness = [D_ins, D_ins, 0.0127]
materials = [Insulation, Insulation, Gypsum]
wall = Element(alb, emis, thickness, materials, 0, 293, 0,
"MetalWall")
# Mass (assume 4" concrete);
alb = 0.2
emis = 0.9
thickness = [0.05, 0.05]
concrete = Material(1.31, 2240.0 * 836.8)
mass = Element(alb, emis, thickness, [concrete, concrete],
0., 293., 1., "MassFloor")
# Roof
if TypeRoof[j][k] == "IEAD": #Insulation Entirely Above Deck
# IEAD-> membrane, insulation, decking
alb = 0.2
emis = 0.93
D_ins = max(RvalRoof[j][k] * Insulation.thermalCond / 2.,
0.01)
roof = Element(alb, emis, [D_ins, D_ins],
[Insulation, Insulation], 0., 293., 0.,
"IEAD")
elif TypeRoof[j][k] == "Attic":
# IEAD-> membrane, insulation, decking
alb = 0.2
emis = 0.9
D_ins = max(RvalRoof[j][k] * Insulation.thermalCond / 2.,
0.01)
roof = Element(alb, emis, [D_ins, D_ins],
[Insulation, Insulation], 0., 293., 0.,
"Attic")
elif TypeRoof[j][k] == "MetalRoof":
# IEAD-> membrane, insulation, decking
alb = 0.2
emis = 0.9
D_ins = max(RvalRoof[j][k] * Insulation.thermalCond / 2.,
0.01)
roof = Element(alb, emis, [D_ins, D_ins],
[Insulation, Insulation], 0., 293., 0.,
"MetalRoof")
# Define bulding energy model, set fraction of the urban floor space of this typology to zero
refBEM[i][j][k] = BEMDef(B, mass, wall, roof, 0.0)
refBEM[i][j][k].building.FanMax = FanFlow[j][
k] # max fan flow rate (m^3/s) per DOE
Schedule[i][j][k] = SchDef()
Schedule[i][j][
k].Elec = SchEquip # 3x24 matrix of schedule for fraction electricity (WD,Sat,Sun)
Schedule[i][j][
k].Light = SchLight # 3x24 matrix of schedule for fraction light (WD,Sat,Sun)
Schedule[i][j][
k].Gas = SchGas # 3x24 matrix of schedule for fraction gas (WD,Sat,Sun)
Schedule[i][j][
k].Occ = SchOcc # 3x24 matrix of schedule for fraction occupancy (WD,Sat,Sun)
Schedule[i][j][
k].Cool = SetCool # 3x24 matrix of schedule for fraction cooling temp (WD,Sat,Sun)
Schedule[i][j][
k].Heat = SetHeat # 3x24 matrix of schedule for fraction heating temp (WD,Sat,Sun)
Schedule[i][j][
k].SWH = SchSWH # 3x24 matrix of schedule for fraction SWH (WD,Sat,Sun
Schedule[i][j][k].Qelec = Elec[
j] # W/m^2 (max) for electrical plug process
Schedule[i][j][k].Qlight = Light[j] # W/m^2 (max) for light
Schedule[i][j][k].Nocc = Occupant[j] / AreaFloor[
j] # Person/m^2
Schedule[i][j][k].Qgas = Gas[j] # W/m^2 (max) for gas
Schedule[i][j][k].Vent = Vent[j] / 1000.0 # m^3/m^2 per person
Schedule[i][j][k].Vswh = SHW[j] / AreaFloor[
j] # litres per hour per m^2 of floor
# if not test serialize refDOE,refBEM,Schedule and store in resources
if serialize_output:
# create a binary file for serialized obj
pkl_file_path = os.path.join(DIR_CURR, '..', 'resources',
'readDOE.pkl')
pickle_readDOE = open(pkl_file_path, 'wb')
# dump in ../resources
# Pickle objects, protocol 1 b/c binary file
cPickle.dump(refDOE, pickle_readDOE, 1)
cPickle.dump(refBEM, pickle_readDOE, 1)
cPickle.dump(Schedule, pickle_readDOE, 1)
pickle_readDOE.close()
return refDOE, refBEM, Schedule
class TestBuildingClass(unittest.TestCase):
"""Class used to test builing is populated and allocates rooms."""
def setUp(self):
self.build = Building("input.txt")
self.build.allocate_to_office()
def test_building_is_populated_with_data(self):
self.assertIsNone(self.build.populate_rooms(), msg="room_directory should be poplated with data from list.")
self.assertIsNone(self.build.get_fellows(), msg="data from returned parser class should be callable")
def test_data_allocation_function_returns_None(self):
self.assertIsNone(self.build.allocate_to_office(), msg="method should return any value")
self.assertIsNone(self.build.allocate_to_livingspace(), msg="method should not return any value")
def test_data_is_printed(self):
self.assertIsNone(self.build.allocated_members_list(), msg="method should print data and not return a value.")
self.assertIsNone(self.build.unallocated_members_list(), msg="method should print data and not return a value.")
self.assertIsNone(self.build.maleroom_members("opal"), msg="should print data and not return a value")
self.assertIsNone(self.build.femaleroom_members("ruby"), msg="should print data and not return a value")
self.assertIsNone(self.build.officeroom_members("Mint"), msg="should print data and not return a value")
#!/usr/bin/env python3
import sys
import json
import coloredlogs
import logging
from building import Building
coloredlogs.install()
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
PLANS = ['training_1', 'training_2', 'training_3', 'ch_rnd_500_1',
'ch_rnd_500_2', 'ch_rnd_500_3', 'ch_clu_500_1', 'ch_clu_500_2',
'ch_clu_500_3', 'ch_rea_1000_1', 'ch_rea_1000_2', 'ch_rea_1000_3']
if __name__ == '__main__':
plan_id = 0
if sys.argv[1] is not None:
plan_id = int(sys.argv[1])
with open('codeliftsettings.json') as settings:
cl_settings = json.load(settings)
building = Building(PLANS[plan_id], cl_settings)
building.connect()
building.start()
logger.info("Finished plan: %s", PLANS[plan_id])
def create_institutions():
'''Creates all institutions in the simulation, setting institution names, infection probabilities, positions,
and door positions. Adds all institutions to INSTITUTION_INT_MAP.'''
campus_outdoors = CampusOutdoors(name= 'campus_outdoors',infec_prob=0.0, posn=[0, 0, 0, 0])
# With old door posns. (flush w/ rest of building)
#disc = Building(name= 'disc',infec_prob=0.0, posn=[528, 574, 256, 393], door_posns=[[574, 296], [574,345], [565, 393]]) # , [528,345]
#uw1 = Building(name= 'uw1',infec_prob=0.0, posn=[364, 575, 478, 515], door_posns=[[364,496], [495, 478], [575, 493], [494, 515],[480, 515]])
#uw2 = Building(name= 'uw2',infec_prob=0.0, posn=[400, 527, 355, 393], door_posns=[[400, 390], [429, 393], [433, 393]])
# With new door posns. protruding from building walls.
disc = Building(name='disc', infec_prob=0.0, posn=[528, 574, 256, 393],
door_posns=[[575, 296], [576, 296], [575, 345], [576, 345],[565, 394], [565, 395],[527,345], [526,345], \
[555, 255 ], [555, 254 ] ] ) # , [528,345]
uw1 = Building(name='uw1', infec_prob=0.0, posn=[364, 575, 478, 515],
door_posns=[[363, 496], [495, 477], [576, 493], [494, 516], [480, 516], \
[362, 496], [495, 476], [577, 493], [494, 517], [480, 517]])
uw2 = Building(name='uw2', infec_prob=0.0, posn=[400, 527, 355, 393],
door_posns=[[399, 390], [429, 394], [433, 394], \
[398, 390], [429, 395], [433, 395], [520, 354], [520, 353], [410, 354], [410, 353],])
lb1 = Building(name= 'lb1',infec_prob=0.0, posn=[621, 752, 421, 470], door_posns=[[664,470]])
lb2 = Building(name= 'lb2',infec_prob=0.0, posn=[725, 780, 486, 570], door_posns=[[725, 486]])
#uwbb = Building(name= 'uwbb',infec_prob=0.0, posn=[1590, 1686, 330, 400], door_posns=[[1630, 400]])
#arc = Building(name= 'arc',infec_prob=0.0, posn=[665, 711, 569, 633], door_posns=[[711,585]])
#subway = Building(name= '',infec_prob=0.0, posn=[604, 620, 432, 468], door_posns=[[611, 470]])
#bus_stop = BusStop(name= 'bus_stop',infec_prob=0.0, posn=[1070, 1144, 340, 447], door_posns=[[1144, 340]])
#bus_stop = BusStop(name= 'bus_stop',infec_prob=0.0, posn=[ - 15, size_x - 10, float(size_y) * 2/3, float(size_y) * 3/4], door_posns=[[840, 480]])
bus_stop = BusStop(name='bus_stop', infec_prob=0.0,
posn=[840, 880, 460, 500], door_posns=[[840, 480]])
#husky_village = StudentHousing(name= 'husky_village',infec_prob=0.0, posn=[1290, 1390, 160, 300], door_posns=[[1290, 160], [1390, 160], [1390, 300]])
# With old door posns. flush with institution boundaries.
#parking_area_1 =ParkingArea(name= 'parking_area_1',infec_prob=0.0, posn=[467, 674, y_offset + 1, 215], door_posns=[[590, 215]])
#parking_area_2 =ParkingArea(name= 'parking_area_2',infec_prob=0.0, posn=[x_offset + 1, 300, y_offset + 1, 525], door_posns=[[300,395]])
# With new door posns. protruding from institution boundaries.
parking_area_1 = ParkingArea(name='parking_area_1', infec_prob=0.0, posn=[467, 674, y_offset + 1, 215],
door_posns=[[590, 216], [590, 217]])
parking_area_2 = ParkingArea(name='parking_area_2', infec_prob=0.0, posn=[x_offset + 1, 300, y_offset + 1, 525],
door_posns=[[301, 395], [302, 395]])
#parking_area_3 =ParkingArea(name= 'parking_area_3',infec_prob=0.0, posn=[996, 1154, 563, 616], door_posns=[[1150, 563]])
#ccc_1_2 = Building(name= 'ccc_1_2',infec_prob=0.0, posn=[818, 1020, 484, 525])
#ccc_3 = Building(name= 'ccc_3',infec_prob=0.0, posn=[892, 1030, 343, 408])
global INSTITUTION_INT_MAP
INSTITUTION_INT_MAP = {0: campus_outdoors, \
1: disc, \
2: uw1, \
3: uw2, \
4: lb1, \
5: lb2, \
#6: uwbb, \
#7: arc, \
#8: subway, \
9: bus_stop, \
#10: husky_village, \
11: parking_area_1, \
12: parking_area_2, \
#13: parking_area_3, \
#14: ccc_1_2, \
#15: ccc_3
}
# Adjust x and y, mins and maxes, and door positions, according to selected size_x and size_y
for instit_int in INSTITUTION_INT_MAP.keys():
instit = INSTITUTION_INT_MAP[instit_int]
for i in range(len(instit.posn)):
if i in [0, 1]: # If it's either x_min or x_max
instit.posn[i] -= x_offset
else:
instit.posn[i] -= y_offset
instit.posn[i] *= (float(size_y)/ orig_img_size_y)
instit.posn[i] = int(math.floor(INSTITUTION_INT_MAP[instit_int].posn[i]))
if INSTITUTION_INT_MAP[instit_int].__class__.__name__ in ['Building', 'ParkingArea', 'BusStop']:
for i in range(len(instit.door_posns)):
instit.door_posns[i][0] -= x_offset
instit.door_posns[i][1] -= y_offset
instit.door_posns[i][0] *= (float(size_y)/ orig_img_size_y)
instit.door_posns[i][1] *= (float(size_y)/ orig_img_size_y)
instit.door_posns[i][0] = int(math.floor(instit.door_posns[i][0]))
instit.door_posns[i][1] = int(math.floor(instit.door_posns[i][1]))
if instit.name in ['uw1', 'uw2', 'disc']:
cols = 5
rows = 2
if instit.name == 'disc':
cols = 2
rows = 5
x_min = instit.posn[0]
x_max = instit.posn[1]
y_min = instit.posn[2]
y_max = instit.posn[3]
width = x_max - x_min
height = y_max - y_min
width_of_one_classroom = (float(width - 2) / cols) - 2 # 2 rows between each classroom and between classrooms and building boundaries
width_of_one_classroom = int(width_of_one_classroom)
height_of_one_classroom = (float(height - 2) / rows) - 2
height_of_one_classroom = int(height_of_one_classroom)
for col in range(cols):
for row in range(rows):
instit.classrooms.append(Classroom(posn=[x_min + 2 + col*(2 + width_of_one_classroom),
x_min + 2 + col*(2 + width_of_one_classroom) + width_of_one_classroom,
y_min + 2 + row * (2 + height_of_one_classroom),
y_min + 2 + row * (2 + height_of_one_classroom) + height_of_one_classroom]))
add_institution_to_grid(instit_int, campus)
from building import Building
from city import City
eight_hundred_eighth = Building("800 8th Street", 12)
eight_hundred_eighth.purchase("Fred Flintstone")
eight_hundred_eighth.construct()
# print(eight_hundred_eighth)
three_hundred = Building("300 Plus Park Blvd", 6)
three_hundred.purchase("Barney Rubble")
three_hundred.construct()
# print(three_hundred)
five_hundred = Building("500 Interstate Blvd", 3)
five_hundred.purchase("Wilma Flintstone")
five_hundred.construct()
# print(five_hundred)
two_hundred = Building("200 28th Street", 20)
two_hundred.purchase("Betty Rubble")
two_hundred.construct()
# print(two_hundred)
megalopolis = City()
megalopolis.add_building(eight_hundred_eighth)
megalopolis.add_building(three_hundred)
megalopolis.add_building(five_hundred)
megalopolis.add_building(two_hundred)
for building in megalopolis.buildings:
print(building)
from building import Building
from domain import Domain
from bson.objectid import ObjectId
# danzi.tn@20160312 import solo delle PK di riferimento sui building
# create main logger
logger = logging.getLogger('smt_main')
logger.setLevel(logging.INFO)
# create a rotating file handler which logs even debug messages
fh = logging.handlers.RotatingFileHandler('import_building_pks.log',maxBytes=5000000, backupCount=5)
fh.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
# reading config file
sCFGName = 'smt.cfg'
smtConfig = ConfigParser.RawConfigParser()
smtConfig.read(sCFGName)
# setup DB parameter
host = smtConfig.get('MONGODB','host')
database = smtConfig.get('MONGODB','database')
source_database = smtConfig.get('MONGODB','source_database')
username = smtConfig.get('MONGODB','username')
password = smtConfig.get('MONGODB','password')
# connect to MongoDB
client = MongoClient()
db = client[database]
# DB authentication
db.authenticate(username,password,source=source_database)
# IMPORT BUILDINGS PKS
Building.import_building_pks(db,"../data/Edifici_Analizzati_Attributi.csv")
class TestBuilding:
"""Test the Building class and its internal methods"""
def setup(self):
settings = {
'bot_name': 'unittest',
'email': '*****@*****.**',
'registration_id': 'test_123'
}
self.building = Building('training_1', settings)
self.building.floors = 10
state = {
'elevators': [
{
'id': 0,
'floor': 0
},
{
'id': 1,
'floor': 0
}
],
'floors': 10
}
self.building.build_elevators(state)
def test_build_elevators(self):
"""Tests that we build all the elevator objects"""
# This is testing that the setup method worked
assert_equals(len(self.building.elevators), 2)
def test_process_elevators(self):
"""Processes the new elevator states"""
state = {
'elevators': [
{
'id': 0,
'floor': 2
},
{
'id': 1,
'floor': 4
}
]
}
self.building.process_elevators(state)
assert_equals(self.building.elevators[0].location, 2)
assert_equals(self.building.elevators[1].location, 4)
def test_process_requests(self):
"""Processes the new elevator requests"""
state = {
'requests': [
{
"direction": -1,
"floor": 3
}
],
'floors': 10
}
self.building.process_requests(state)
[e.get_command() for e in self.building.elevators]
elevator = self.building.elevators[0]
assert_equals(elevator.next_direction, -1)
state = {
'requests': [
{
"direction": -1,
"floor": 3
},
{
"direction": 1,
"floor": 5
}
],
'floors': 10
}
self.building.process_requests(state)
[e.get_command() for e in self.building.elevators]
elevator1 = self.building.elevators[0]
elevator2 = self.building.elevators[1]
assert_equals(elevator1.cur_direction, 1)
assert_equals(elevator1.next_direction, -1)
assert_equals(elevator2.cur_direction, 1)
assert_equals(elevator2.next_direction, 1)
def test_add_acked(self):
"""Adds a request to the acked list"""
state = {
'requests': [
{
"direction": -1,
"floor": 3
}
],
'floors': 10
}
self.building.process_requests(state)
expected = Request(3, -1)
assert_equals(expected, self.building.acked[0])
def test_remove_acked(self):
"""Removes a finished request from the acked list"""
state = {
'requests': [
{
"direction": -1,
"floor": 3
}
],
'floors': 10
}
self.building.process_requests(state)
assert_equals(len(self.building.acked), 1)
state = {
'elevators': [
{
'id': 0,
'floor': 3
}
]
}
self.building.process_elevators(state)
self.building.generate_commands()
assert_equals(len(self.building.acked), 0)
def test_find_cheapest_elevator_equal(self):
request = Request(floor=9, direction=-1)
result = self.building.find_cheapest_elevator(request, 10)
assert_equals(result, self.building.elevators[0])
def test_find_cheapest_elevator_closer(self):
state = {'elevators': [{'id': 1, 'floor': 5}], 'floors': 10}
self.building.process_elevators(state)
request = Request(floor=9, direction=-1)
result = self.building.find_cheapest_elevator(request, 10)
assert_equals(result, self.building.elevators[1])
def test_manage_idle_elevators(self):
self.building.elevators[0].wait_count = 3
self.building.elevators[0].playing = True
self.building.elevators[1].wait_count = 3
self.building.elevators[1].playing = True
commands = self.building.generate_commands()
self.building.manage_idle_elevators(commands)
for command in commands:
assert_equals(command.direction, 1)
assert_equals(command.speed, 1)
state = {'requests': [{'floor': 5, 'direction': -1}]}
self.building.process_requests(state)
commands = self.building.generate_commands()
for command in commands:
assert_equals(command.direction, 1)
assert_equals(command.speed, 1)
def test_manage_idle_elevators_more(self):
state = {'elevators': [{'id': 0, 'floor': 6}]}
self.building.process_elevators(state)
self.building.elevators[0].wait_count = 3
self.building.elevators[0].playing = True
self.building.elevators[1].wait_count = 3
self.building.elevators[1].playing = True
state = {'requests': [{'floor': 5, 'direction': -1}]}
self.building.process_requests(state)
commands = self.building.generate_commands()
assert_equals(commands[0].direction, -1)
assert_equals(commands[0].speed, 1)
assert_equals(commands[1].direction, 1)
assert_equals(commands[1].speed, 1)
def setUp(self):
self.build = Building("input.txt")
self.build.allocate_to_office()
def finder(file_name, test):
""""Функция составляет базу данных из OSM-кого формата"""
try:
if not test:
coord_path = os.path.join("./test_base",
"Russia_coordinates.db")
buildings_path = os.path.join("./test_base",
"Russia_buildings.db")
else:
coord_path = os.path.join("./test_base", "test_coordinates.db")
buildings_path = os.path.join("./test_base",
"test_buildings.db")
con1 = sqlite3.connect(coord_path)
cur1 = con1.cursor()
cur1.execute(
'CREATE TABLE IF NOT EXISTS coordinates_base(Link INTEGER, Lat REAL, Lon REAL)'
)
con2 = sqlite3.connect(buildings_path)
cur2 = con2.cursor()
cur2.execute(
'CREATE TABLE IF NOT EXISTS address_base(City TEXT,Address TEXT,House_number TEXT,Links TEXT)'
)
with open(file_name, encoding='utf-8') as f:
buffer = []
counter = 0
current_city = ""
for string in f:
string = string.lstrip()[:-1]
buffer.append(string)
if counter <= 0:
if re.match(r'<node id="', string) is not None:
try:
s = re.findall(r'[0-9]{2}.[0-9]+', string)
coordinates = ([
int(s[0]),
float(s[4]),
float(s[5])
])
cur1.execute(
"INSERT INTO coordinates_base VALUES(?,?,?)",
coordinates)
except IndexError:
continue
if re.match(r'<tag k="addr:street" v="',
string) is not None:
j = 0
is_house = False
for j in range(len(buffer) - 1, -1, -1):
if re.match(r'<way id="',
buffer[j]) is not None:
is_house = True
break
if is_house:
references = []
street = string[24:-3]
house_number = None
city = current_city
for i in range(j, len(buffer)):
if re.match(
r'<tag k="addr:housenumber" v=',
buffer[i]) is not None:
house_number = buffer[i][29:-3]
continue
if re.match(r'<tag k="addr:city" v=',
buffer[i]) is not None:
city = buffer[i][22:-3].capitalize()
current_city = city
if re.match(r'<nd ref="',
buffer[i]) is not None:
references.append(buffer[i][9:-3])
if house_number is not None:
build = Building(street, house_number,
references, city)
references = " ".join(build.references)
cur2.execute(
"INSERT INTO address_base VALUES(?,?,?,?)",
[
build.city, build.address,
build.house_number, references
])
elif house_number is None:
counter = 5
elif counter > 0:
counter -= 1
if re.match(r'<tag k="addr:housenumber" v=',
string) is not None:
counter = 0
j = 0
is_house = False
for j in range(len(buffer) - 1, -1, -1):
if re.match(r'<way id="',
buffer[j]) is not None:
is_house = True
break
if is_house:
references = []
house_number = string[29:-3]
city = current_city
street = None
for i in range(j, len(buffer)):
if re.match(r'<tag k="addr:street"',
buffer[i]) is not None:
street = buffer[i][24:-3]
continue
if re.match(r'<nd ref="',
buffer[i]) is not None:
references.append(buffer[i][9:-3])
if re.match(r'<tag k="addr:city" v=',
buffer[i]) is not None:
city = buffer[i][22:-3].capitalize()
current_city = city
if street is not None:
build = Building(street, house_number,
references, city)
references = " ".join(build.references)
cur2.execute(
"INSERT INTO address_base VALUES(?,?,?,?)",
[
build.city, build.address,
build.house_number, references
])
if len(buffer) == 40:
buffer.pop(0)
con1.commit()
con2.commit()
except FileNotFoundError:
raise FileNotFoundError("База OSM не загружена!")
from building import Building, Customer, Elevator
while True:
num_floors = input("Please give the number of floors:")
num_customers = input("Please give the number of customers:")
try:
floors = int(num_floors)
customers = int(num_customers)
except ValueError:
print("You didn't enter a valid number")
continue
if floors <= 0:
print("Please enter a number of floors that is above 0")
continue
if customers <= 0:
print("Please enter a number of customers that is above 0")
continue
b = Building(floors, customers)
print('Made a building with customers', b)
b.elevator.go_up()
b.elevator.go_down()
break
def __init__(self, name: str, address: str):
"""Constructor"""
Building.__init__(self, name, address)
self.__menu = []
self.__orders = []
self.__waiters = []
from person import Person
print "Welcome to the building manager application!"
response = raw_input("Would you like to add a (b)uilding, (a)partment, (r)enter, or (q)uit? ")
while response != "q":
if response == "b":
name = raw_input("What is the name of this building? ")
address = raw_input("What is the address? ")
num_floors = raw_input("How many floors are in the building? ")
doorman = raw_input("Does the building have a doorman? (t/f)")
if doorman == "t":
doorman = True
else:
doorman = False
building = Building(name=name, address=address, num_floors=num_floors, doorman=doorman)
print "Thanks for adding building {0}".format(building)
if response == "a":
unit = raw_input("What is the unit number? ")
rent = raw_input("What is the monthly rent? ")
sqft = raw_input("How many sq feet are in the apartment? ")
num_bedrooms = raw_input("How many bedrooms does it have? ")
num_bathrooms = raw_input("How many bathrooms does it have? ")
apartment = Apartment(unit=unit, rent=rent, sqft=sqft, num_bedrooms=num_bedrooms, num_bathrooms=num_bathrooms)
try:
building.apartments[unit] = apartment
print "Thanks for adding unit {0} to building {1}".format(apartment.unit, building.name)
except NameError:
print "You have to add a building first"
if __name__ == '__main__':
pygame.init()
logging = get_log.get_logger()
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption('Dragon quest monster')
icon = pygame.image.load(SLIME_IMG_PATH)
pygame.display.set_icon(icon)
field = BackGround(FIELD_IMG_PATH, screen.get_height(), screen.get_width())
combat = BackGround(COMBAT_IMG_PATH, screen.get_height(), screen.get_width())
carve = Building(CARVE_IMG_PATH, screen.get_height(), screen.get_width())
braver = Braver('mike', BRAVER_IMG_PATH, screen.get_height(), screen.get_width())
slime = Slime('kororo', SLIME_IMG_PATH, screen.get_height(), screen.get_width())
is_running: bool = True
while is_running:
screen.fill((0, 0, 0))
back_ground = field.pg_img
for event in pygame.event.get():
if event.type == pygame.QUIT:
is_running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
logging.debug('key up')
# -*- coding: utf-8 -*-
from building import Building
if __name__ == '__main__':
chartreuse = Building('m', "8C - Chartreuse")
from building import Building
from city import City
westin = Building("Westin", "807 Clark Place", 26)
jw = Building("JW", "201 8th Ave S", 28)
hilton = Building("Hilton", "121 4th Ave S", 18)
sheraton = Building("Sheraton", "623 Union St", 33)
union_station = Building("Union Station", "1001 Broadway", 9)
westin.purchase("Mama Bear")
jw.purchase("Papa Bear")
hilton.purchase("Sister Bear")
sheraton.purchase("Brother Bear")
union_station.purchase("Honey Bear")
westin.construct()
jw.construct()
hilton.construct()
sheraton.construct()
union_station.construct()
megalopolis = City("Megalopolis", "Kitty Baby", 2012)
megalopolis.add_building(westin)
megalopolis.add_building(jw)
megalopolis.add_building(hilton)
megalopolis.add_building(sheraton)
megalopolis.add_building(union_station)
print(f'{megalopolis.mayor} is the mayor of the wonderful city of {megalopolis.name}, which was founded in {megalopolis.year}. The following lavish building are located in {megalopolis.name}:')
print()
def create_building(world, scenario_state, sound_system):
up_door = world.entity()
up_door.add_components(
Positionable(0, 0, 50, 100),
Renderable(
lambda brush: brush.draw_image("door2_t.png"),
3
),
TilePositionable("wall", (8, 1), 1),
Activable(False)
)
left_door = world.entity()
left_door.add_components(
Positionable(0, 0, 50, 100),
Renderable(
lambda brush: brush.draw_image("door2_l.png"),
3
),
TilePositionable("wall", (0, 6), 3),
Activable(False)
)
down_door = world.entity()
down_door.add_components(
Positionable(0, 0, 50, 100),
Renderable(
lambda brush: brush.draw_image("door2_b.png"),
3
),
TilePositionable("wall", (8, 10), 3),
Activable(False)
)
right_door = world.entity()
right_door.add_components(
Positionable(0, 0, 100, 50),
Renderable(
lambda brush: brush.draw_image("door2_r.png"),
3
),
TilePositionable("wall", (12, 6), 3),
Activable(False)
)
up_window = world.entity()
up_window.add_components(
Positionable(0, 0, 100, 100),
Renderable(
lambda brush: brush.draw_image("window_t.png"),
1
),
TilePositionable("wall", (7, 1), 1),
Activable(False)
)
left_window = world.entity()
left_window.add_components(
Positionable(0, 0, 100, 100),
Renderable(
lambda brush: brush.draw_image("window_l.png"),
1
),
TilePositionable("wall", (0, 3), 1),
Activable(False)
)
down_window_renderable = Renderable(
lambda brush: brush.draw_image("window_b.png"),
1
)
down_window_toggled = [False]
def toggle_down_window():
down_window_renderable.render_image(
"window_b.png" if down_window_toggled[0] else "window_semiopen_b.png",
(0, 0) if down_window_toggled[0] else (-24, 0)
)
down_window_toggled[0] = not down_window_toggled[0]
sound_system.play("window")
down_window = world.entity()
down_window.add_components(
Positionable(0, 0, 100, 100),
down_window_renderable,
TilePositionable("wall", (4, 10), 1),
Clickable(
toggle_down_window,
Button.LEFT
),
Activable(False)
)
add_cursor_change_hoverable(down_window)
def is_activated(entity):
return entity.get_component(Activable).activated
scenario_state["has_window"] = lambda: is_activated(up_window)
scenario_state["has_down_door"] = lambda: is_activated(down_door)
scenario_state["has_up_door"] = lambda: is_activated(up_door)
scenario_state["has_right_door"] = lambda: is_activated(right_door)
scenario_state["window"] = up_window
building = Building(
[
Room((0, 0), [left_door, right_door, down_door, left_window]),
Room((0, 30), [up_door, left_window]),
Room((30, 0), [left_door, down_door, up_window]),
Room((30, 30), [up_door, down_window])
],
(30, 30)
)
scenario_state["minimap"] = create_minimap(world, (700, 50), building)
for i in range(2, 5):
bookshelf = world.entity()
bookshelf.add_components(
Positionable(0, 0, 50, 100),
Renderable(
lambda brush: brush.draw_image("bookshelf.png"),
1
),
TilePositionable("ground", (i, 1), 1)
)
if i == 2:
def bookshelf_move(animable, scenario_state, direction, duration):
def move():
animable.add_animation(
TileMoveAnimation(direction, duration)
)
scenario_state["bookshelf_moved"] =\
not scenario_state["bookshelf_moved"]
sound_system.play("furniture")
return move
animable = Animable()
scenario_state["bookshelf_moved"] = False
scenario_state["bookshelf_move_left"] =\
bookshelf_move(animable, scenario_state, (-2, 0), 1)
scenario_state["bookshelf_move_right"] =\
bookshelf_move(animable, scenario_state, (2, 0), 1)
scenario_state["bookshelf_can_move"] = True
def toggle_bookshelf(bookshelf):
def toggle():
if scenario_state["bookshelf_can_move"]:
if scenario_state["bookshelf_moved"]:
scenario_state["bookshelf_move_right"]()
else:
scenario_state["bookshelf_move_left"]()
return toggle
bookshelf.add_components(
animable,
Clickable(
toggle_bookshelf(bookshelf),
Button.LEFT
),
Frightening()
)
add_cursor_change_hoverable(bookshelf)
fireplace_anim = Animable()
fireplace_anim.add_animation(
FlickerAnimation(6, 0.3)
)
fireplace = world.entity()
fireplace.add_components(
Positionable(0, 0, 100, 100),
Renderable(
lambda brush: brush.draw_image("fireplace.png"),
1
),
TilePositionable("ground", (8, 1), 1),
Lightable(
Positionable(-130, 60, 360, 120),
Positionable(-230, 30, 560, 200),
(205, 155, 29, 64)
),
fireplace_anim
)
scenario_state["fireplace"] = fireplace
from building import Building, big_building
from city import City
# Name of the city.
# The mayor of the city.
# Year the city was established.
# A collection of all of the buildings in the city.
# A method to add a building to the city.
megalopolis = City()
# Awesome code here
for building in megalopolis.buildings:
print(building)
megalopolis.name = "Big Town"
megalopolis.city = ["Wuts up"]
megalopolis.mayor = "Bob Jones"
megalopolis.year = "1815"
small_building = Building("700 7th Street", 13)
small_building.construct()
small_building.purchase("Cob")
megalopolis.add_building(small_building)
megalopolis.add_building(big_building)
megalopolis.destroy_city()
for building in megalopolis.buildings:
print(building.address)
'''Script use to view result of allocation.'''
from building import Building
from fileparser import Parser
amity = Building('input.txt');
amity.populate_rooms()
amity.get_fellows()
amity.allocate_to_office()
amity.allocate_to_livingspace()
amity.allocated_members_list()
amity.unallocated_members_list()
amity.maleroom_members('opal')
amity.femaleroom_members('ruby')
amity.officeroom_members('Mint')
from building import Building
from city import City
three_o_one = Building("301 Plus Park", 4)
five_hundred = Building("500 Interstate Blvd S", 5)
executive_south = Building("1 Executive South", 10)
curts_house = Building("100 Curt's House", 2)
large_skyscraper = Building("3030 Oprah Rd", 100)
three_o_one.purchase("Dr. Phil")
five_hundred.purchase("Joe Shep")
executive_south.purchase("Drew Pazola")
curts_house.purchase("Curt Cato")
large_skyscraper.purchase("Oprah")
three_o_one.construct()
five_hundred.construct()
executive_south.construct()
curts_house.construct()
large_skyscraper.construct()
megalopolis = City()
megalopolis.add_building(three_o_one)
megalopolis.add_building(five_hundred)
megalopolis.add_building(executive_south)
megalopolis.add_building(curts_house)
megalopolis.add_building(large_skyscraper)
for building in megalopolis.buildings:
print(building)
def query_bbl(self, bbl):
borough = bbl.borough
block = bbl.block
lot = bbl.lot
bbl_repr = bbl.bbl_repr
print "BBL:", bbl
#This is the output
building = Building(bbl)
print "=== STEP 1: ==="
lot_records = list(self.db.lot_records.find({'Borough':borough,'Block':block,'Lot':lot}))
print "Found", len(lot_records), "records in lot_records..."
unique_keys = list()
for lot_record in lot_records:
unique_keys.append(lot_record['Unique_Key'])
master_records = list(self.db.master_records.find({'Unique_Key':{'$in':unique_keys}}))
print "Found", len(master_records), "records in master_records..."
latest_unique_key = None
latest_doc_date = datetime.strptime('1970-01-01', '%Y-%m-%d')
for master_record in master_records:
if master_record['Document_Date'] == "":
continue
if master_record['Doc_type'][0:4] == 'DEED':
if datetime.strptime(master_record['Document_Date'], '%Y-%m-%d') > latest_doc_date:
latest_unique_key = master_record['Unique_Key']
latest_doc_date = datetime.strptime(master_record['Document_Date'], '%Y-%m-%d')
if latest_unique_key is None:
print "Nothing found!"
return None
elif str(latest_unique_key)[0:3] == "BK_" or str(latest_unique_key)[0:3] == "FT_":
print "Latest UK is", latest_unique_key
print "We're not interested in this type of property!"
return None
else:
print "Latest UK is", latest_unique_key
#FINISH STEP 1
print "=== STEP 2: ==="
party_records = list(self.db.party_records.find({'Unique_Key':latest_unique_key}))
print "Found", len(party_records), "records in party_records..."
primary_party = None
for party_record in party_records:
if party_record['Party_type'] == 2:
primary_party = Owner({
'name': self.normalize_str(party_record['Name']),
'addr1': self.normalize_str(party_record['Addr1']),
'addr2': self.normalize_str(party_record['Addr2']),
'city': party_record['City'],
'state': party_record['State'],
'zip': party_record['Zip']
})
if primary_party is None:
print "No name found!"
return None
else:
print "Primary party is ", primary_party['name']
print primary_party
building.primary = primary_party
#FINISH STEP 2
print "=== STEP 3: ==="
secondary_unique_keys = list()
for master_record in master_records:
if master_record['Document_Date'] == "":
continue
if datetime.strptime(master_record['Document_Date'], '%Y-%m-%d') < latest_doc_date:
continue
#if master_record['doc_type'][0:4] == 'MTGE' or master_record['doc_type'][0:4] == 'AGMT':
if master_record['Doc_type'][0:4] == 'MTGE': #Not consider AGMT right now
secondary_unique_keys.append(master_record['Unique_Key'])
print "Found", len(secondary_unique_keys), "secondary UKs: ", secondary_unique_keys
#FINISH STEP 3
print "=== STEP 4: ==="
party_records = list(self.db.party_records.find({'Unique_Key':{'$in': secondary_unique_keys}}))
print "Found", len(party_records), "records in party_records..."
secondary_parties = set()
for party_record in party_records:
if party_record['Party_type'] == 1:
secondary_party = Owner({
'name': self.normalize_str(party_record['Name']),
'addr1': self.normalize_str(party_record['Addr1']),
'addr2': self.normalize_str(party_record['Addr2']),
'city': party_record['City'],
'state': party_record['State'],
'zip': party_record['Zip']
})
secondary_parties.add(secondary_party)
print "Found", len(secondary_parties), "secondary parties..."
for secondary_party in secondary_parties:
print "Name:", secondary_party['name']
print secondary_parties
building.secondary = secondary_parties
#FINISH STEP 4
print "=== STEP 5: ==="
lot_records = list(self.db.lot_records.find({'Unique_key':{'$in': secondary_unique_keys}}))
print "Found", len(lot_records), "records in lot_records..."
cache_bbls = set([bbl])
for lot_record in lot_records:
secondary_bbl = BBL(lot_record['Borough'], lot_record['Block'], lot_record['Lot'])
cache_bbls.add(secondary_bbl)
secondary_bbls = cache_bbls.difference(set([bbl]))
print "These are secondary BBLs:"
for secondary_bbl in secondary_bbls:
print secondary_bbl
building.linkedbbls = secondary_bbls
#FINISH STEP 5
print "=== STEP 6: HPD ==="
hpd_records = list(self.db.hpd.find({'bbl':bbl_repr}))
print "Found", len(hpd_records), "records in hpd..."
#Get the first one
if len(hpd_records) == 0:
print "No HPD records!"
else:
hpd_record = hpd_records[0]
hpd_reg_id = hpd_record['RegistrationID']
#FINISH STEP 6
print "=== STEP 7: HPD Contacts ==="
hpd_contact_records = list(self.db.hpd_contact.find({'RegistrationID': hpd_reg_id}))
print "Found", len(hpd_contact_records), "records in hpd_contacts..."
hpd_parties = set()
for hpd_contact_record in hpd_contact_records:
hpd_party = Owner({
'name': str(hpd_contact_record['LastName']) + ', ' + str(hpd_contact_record['FirstName']),
'addr1': str(hpd_contact_record['BusinessHouseNumber']) + ' ' + str(hpd_contact_record['BusinessStreetName']),
'addr2': hpd_contact_record['BusinessApartment'],
'city': hpd_contact_record['BusinessCity'],
'state': hpd_contact_record['BusinessState'],
'zip': hpd_contact_record['BusinessZip'],
'description': hpd_contact_record['ContactDescription'],
'corporation_name': hpd_contact_record['CorporationName']
})
hpd_parties.add(hpd_party)
print hpd_parties
building.hpd = hpd_parties
#FINISH STEP 7
print "=== STEP 8: DOF Tax Bills ==="
tax_records = list(self.db.dof_taxes.find({'id-boro':borough, 'id-block':block, 'id-lot':lot}))
print "Found", len(tax_records), "records in DOF tax bills..."
#Extract information
tax_parties = set()
for tax_record in tax_records:
tax_party = Owner({
'name': str(tax_record['nm-recipient-1']) + ' ' + str(tax_record['nm-recipient-2']) + ' ' + str(tax_record['ad-name-attention']),
'addr1': str(tax_record['ad-street-no']) + ' ' + str(tax_record['ad-street-1']),
'addr2': tax_record['ad-street-2'],
'city': tax_record['ad-city'],
'state': tax_record['cd-addr-state'],
'zip': tax_record['cd-addr-zip']
})
tax_parties.add(tax_party)
print tax_parties
building.tax = tax_parties
#FINISH STEP 8
print "STEP 9: DOS"
#Need to do it fuzzily by matching name?
return building
def get_t_zco_from_registers(self):
return self.holding_register_block.getValues(t_zco_address, 1)
if __name__ == '__main__':
# start new server
server = Server('', PORT)
# add a callback function which will be called with new timestamp each time new time is received
server.set_time_flag_callback(step)
# run the server
server.run()
print('Server is running')
water_flow_controller = WaterFlowController()
logger = Logger()
building = Building()
close = False
while not close:
try:
time.sleep(10)
input_str = input()
if input_str == 'close':
close = True
except KeyboardInterrupt:
close = True
print('Server is closing')
# remember to stop server while closing your application
server.stop()
print('finished!')
def export_buildings_data(authenticate, csv_path, shp_path):
'''
funzione che fa il vero lavoro
'''
logger = init_logger('smt_main', 'export_building_data.log')
smt_config = get_config('smt.cfg')
# connect to MongoDB
client = MongoClient()
mongodb = client[smt_config.get('MONGODB', 'database')]
# DB authentication if required
if authenticate:
logged_in = mongodb.authenticate(smt_config.get('MONGODB', 'username'),
smt_config.get('MONGODB', 'password'),
source=smt_config.get('MONGODB', 'source_database'))
else:
logged_in = True
if logged_in:
dati = [{"field":"bldg_code", "csv_field":"ID_bati", "shp_field":"bldg_code", "multiplier":0},
{"field":"pk_min-tun", "csv_field":"PK début", "shp_field":"pk_min-tun", "multiplier":1},
{"field":"pk_max-tun", "csv_field":"PK fin", "shp_field":"pk_max-tun", "multiplier":1},
{"field":"d_min-tun", "csv_field":"Distance horizontale minimale à l'axe du tunnel", "shp_field":"d_min-tun", "multiplier":1},
{"field":"d_max-tun", "csv_field":"Distance horizontale maximale à l'axe du tunnel", "shp_field":"d_max-tun", "multiplier":1},
{"field":"pk_min-smi", "csv_field":"PK début", "shp_field":"pk_min-smi", "multiplier":1},
{"field":"pk_max-smi", "csv_field":"PK fin", "shp_field":"pk_max-smi", "multiplier":1},
{"field":"d_min-smi", "csv_field":"Distance horizontale minimale à l'axe du tunnel", "shp_field":"d_min-smi", "multiplier":1},
{"field":"d_max-smi", "csv_field":"Distance horizontale maximale à l'axe du tunnel", "shp_field":"d_max-smi", "multiplier":1},
{"field":"sc_lev", "csv_field":"Classe de sensibilité", "shp_field":"sc_lev", "multiplier":1},
{"field":"damage_class", "csv_field":"Classe de dommage", "shp_field":"dmg_cls", "multiplier":1},
{"field":"vulnerability", "csv_field":"Vulnérablité", "shp_field":"vuln", "multiplier":1},
{"field":"settlement_max", "csv_field":"Settlement max", "shp_field":"sett_max", "multiplier":1000},
{"field":"tilt_max", "csv_field":"Tilt max", "shp_field":"tilt_max", "multiplier":1000},
{"field":"esp_h_max", "csv_field":"Esp h max", "shp_field":"esph_max", "multiplier":1000},
{"field":"damage_class_base", "csv_field":"Classe de dommage base", "shp_field":"dmg_cls_b", "multiplier":1},
{"field":"vulnerability_base", "csv_field":"Vulnérablité base", "shp_field":"vuln_b", "multiplier":1},
{"field":"settlement_max_base", "csv_field":"Settlement max base", "shp_field":"sett_max_b", "multiplier":1000},
{"field":"tilt_max_base", "csv_field":"Tilt max base", "shp_field":"tilt_max_b", "multiplier":1000},
{"field":"esp_h_max_base", "csv_field":"Esp h max base", "shp_field":"esph_max_b", "multiplier":1000},
{"field":"damage_class_vibration", "csv_field":"Classe de dommage - Vibration", "shp_field":"dmg_cls_vbr", "multiplier":1},
{"field":"vulnerability_class_vibration", "csv_field":"Vulnérablité - Vibration", "shp_field":"vuln_vbr", "multiplier":1},
{"field":"vibration_speed_mm_s", "csv_field":"Vitessse de vibration", "shp_field":"vbr_speed", "multiplier":1}]
# EXPORT BUILDINGS CALCULATED DATA
with open(csv_path, 'wb') as out_csvfile:
writer = csv.writer(out_csvfile, delimiter=";")
writer.writerow([x["csv_field"] for x in dati])
bcurr = Building.find(mongodb, {"PK_INFO":{"$exists":True}})
if bcurr.count == 0:
logger.error("No Buildings found!")
else:
shape_data = open_shapefile(shp_path, logger)
if shape_data:
layer = append_fields_to_shapefile(shape_data,
[x["shp_field"] for x in dati[1:]], logger)
for item in bcurr:
building = Building(mongodb, item)
building.load()
bldg_code = building.item["bldg_code"]
if layer:
bldg_feature = find_first_feature(layer, "bldg_code", bldg_code)
if not bldg_feature:
logger.warn("No feature with bldg_code %s found", bldg_code)
logger.debug("Processing building %s", bldg_code)
row = []
for dato in dati:
if dato["field"] == "bldg_code":
field_value = building.item["bldg_code"]
elif dato["field"].split("_", 1)[0] in ["d", "pk"]:
field, align = dato["field"].split("-", 1)
pk_array = building.item["PK_INFO"]["pk_array"]
if align == "smi":
field_value = next((l[field] for l in pk_array if l['pk_min'] > 2150000), None)
else:
field_value = next((l[field] for l in pk_array if l['pk_min'] < 2150000), None)
else:
field_value = building.item.get(dato["field"], 0) * dato["multiplier"]
row.append(str(field_value))
if bldg_feature and field_value and dato["field"] != "bldg_code":
logger.debug("Trying to set field %s of building %s to value %0.10f",
dato["shp_field"][:10], bldg_code, field_value)
bldg_feature.SetField(dato["shp_field"][:10], field_value)
writer.writerow(row)
if layer and bldg_feature:
layer.SetFeature(bldg_feature)
if shape_data:
shape_data.Destroy()
logger.info("Buildings data Exported")
from building import Building
from city import City
# Create a new city instance and add your building instances to it.
# Once all buildings are in the city, iterate the city's building
# collection and output the information about each building in the city.
eight_hundred_eighth = Building("800 8th Street", 12)
seven_hundred_seventh = Building("700 7th Street", 44)
six_hundred_sixth = Building("600 6th Street", 13)
five_hundred_fifth = Building("500 5th Street", 99)
four_hundred_forth = Building("400 4th Street", 88)
eight_hundred_eighth.purchase("Kid Frost")
seven_hundred_seventh.purchase("MC Eight")
six_hundred_sixth.purchase("Dr. Dre")
five_hundred_fifth.purchase("B. Real")
four_hundred_forth.purchase("Mr. Cartoon")
eight_hundred_eighth.construct()
seven_hundred_seventh.construct()
six_hundred_sixth.construct()
five_hundred_fifth.construct()
four_hundred_forth.construct()
megalopolis = City()
megalopolis.add_building(eight_hundred_eighth)
megalopolis.add_building(seven_hundred_seventh)
megalopolis.add_building(six_hundred_sixth)
megalopolis.add_building(five_hundred_fifth)
def print_menu(): #prints terminal menu
while True:
to_do = raw_input("What do you want to do?\n--Add (N)ew building\n--Review the (B)uilding information\n--add new (A)partment\n--(L)ook up apartment information\n--add new (R)enter\n--check apartment (O)ccupancy\n--(Q)uit\n ").lower()
if to_do == 'n': #adds new building
number = int(raw_input("\nWhat is the building number? "))
address = raw_input("\nWhat is the building address? ")
doorman = raw_input("\nDoes the building have a doorman? (T) or (F)") #work on, convert to boolean
number_units = int(raw_input("\nHow many units does the building have?"))
building = Building(number,address,number_units, doorman)
print "\nBuilding Number: %s Added\n" % (building.building_number)
elif to_do == 'b': #asks for building information
building_number = int(raw_input("\nWhich building number do you want information on? "))
building = Building.building_list[building_number]
building_info = raw_input("\nWhat do you want to look up?\n--(A)ddress\n--(D)oorman\n--(N)umber of Units?\n ").lower()
if building_info == 'a':
print building.address
elif building_info == 'd':
print building.doorman
elif building_info == 'n':
print building.number_units
else:
print "\nSorry I could not understand\n"
elif to_do == 'a': #adds new apartment
building_number = int(raw_input("What is the building number? "))
building = Building.building_list[building_number]
unit_number = int(raw_input("What is the unit number? "))
rent = int(raw_input("What is the rent per month? "))
square_footage = int(raw_input("What is the square_footage? "))
bathrooms = int(raw_input("Number of bathrooms? "))
apartment = building.add_apartment(unit_number, rent, square_footage, bathrooms)
print "\nApartment Number: %s added to building number %s\n" % (apartment.unit_number,building)
elif to_do == 'l': #requests apartment information
building_number = int(raw_input("Which building number is the apartment located in? "))
unit_number = int(raw_input("Which apartment number? "))
print "unit number %s" %(unit_number)
building = Building.building_list[building_number]
apartment = building.apartment_dict[unit_number]
apt_info = raw_input("What do you want to look up?\n--(R)ent\n--(S)quare footage\n--(N)umber of bathrooms\n--Ren(T)er\n--(O)ccupied? ").lower()
if apt_info == 'r':
print apartment.rent
elif apt_info == 's':
print apartment.square_footage
elif apt_info == 'n':
print apartment.number_bathrooms
elif apt_info == 't':
print apartment.renter
elif apt_info == 'o':
print apartment.occupied
else:
print "\nSorry I could not understand\n"
#finish loop here
elif to_do =='r': #adds renter
building_number = int(raw_input("Which building number is the renter located in? "))
building = Building.building_list[building_number]
unit_number = int(raw_input("Which apartment number? "))
apartment = building.apartment_dict[unit_number]
name = raw_input("What is the renter's name? ")
renter = apartment.add_renter(name)
print "\nRenter: %s, added to building number: %s and unit number %s\n" % (renter.name, renter.building_number, renter.apartment_number)
elif to_do == 'o': #checks apartment occupancy
building_number = int(raw_input("Which building number is the apartment located in? "))
unit_number = int(raw_input("Which apartment number? "))
building = Building.building_list[building_number]
apartment = building.apartment_dict[unit_number]
result = apartment.check_occupied()
if True:
print "\nOCCUPIED\n"
else:
print "\nUNOCCUPIED\n"
elif to_do == 'q': #quits the program
print "\nThanks for using Manager Client!\n"
return False
else:
print "\nSorry, I don't understand what you want.\n"
