def _populate_region_index(self):
units = self.get_and_sort(self.undp_export + '/report_units.csv',
'bureau')
choices = ['PAPP', 'RBA', 'RBAP', 'RBAS', 'RBEC', 'RBLAC']
for unit in units:
if (unit['bureau'] in choices
and unit['hq_co'] == 'HQ') or unit['bureau'] == 'PAPP':
if unit['ou_descr'] != 'Regional Center - Addis Ababa':
obj = Region()
obj.name.value = unit['ou_descr']
obj.id.value = unit['bureau']
try:
self.region_index.add(obj.id.value, obj)
except ObjectExists:
pass
obj = Region()
obj.name.value = 'Global'
obj.id.value = 'global'
self.region_index.add(obj.id.value, obj)
def import_legacy_annotation(a, video_obj, frame, vdn_dataset=None):
da = Region()
da.region_type = Region.ANNOTATION
da.video = video_obj
da.x = a['x']
da.y = a['y']
da.h = a['h']
da.w = a['w']
da.vdn_key = a['id']
if vdn_dataset:
da.vdn_dataset = vdn_dataset
if a['label'].strip():
da.object_name = a['label']
da.frame = frame
da.full_frame = a['full_frame']
da.metadata_text = a['metadata_text']
da.metadata_json = a['metadata_json']
da.save()
if a['label'].strip():
dl = AppliedLabel()
dl.region = da
dl.label_name = a['label']
dl.video = da.video
dl.frame = da.frame
dl.save()
return da
def import_region(a,video_obj,frame,detection_to_pk,vdn_dataset=None):
da = Region()
da.video = video_obj
da.x = a['x']
da.y = a['y']
da.h = a['h']
da.w = a['w']
da.vdn_key = a['id']
da.metadata_text = a['metadata_text']
da.metadata_json = a['metadata_json']
da.region_type = a['region_type']
da.confidence = a['confidence']
da.object_name = a['object_name']
da.full_frame = a['full_frame']
if vdn_dataset:
da.vdn_dataset = vdn_dataset
if 'label' in a and a['label'].strip():
da.label = a['label']
if vdn_dataset:
label_object, created = VLabel.objects.get_or_create(label_name=a['label'], source=VLabel.VDN, video=video_obj, vdn_dataset=vdn_dataset)
else:
label_object, created = VLabel.objects.get_or_create(label_name=a['label'], source=VLabel.UI, video=video_obj)
da.label_parent = label_object
da.frame = frame
da.save()
if da.region_type == Region.DETECTION:
detection_to_pk[a['id']]=da.pk
return da
def define_available_regions(self):
api_settings = g.db.api_settings.find_one()
form = forms.RegionSet()
if request.method == 'POST' and form.validate_on_submit():
region = Region(request.form)
if api_settings.get('regions'):
g.db.api_settings.update(
{'_id': api_settings.get('_id')},
{'$push': {
'regions': region.__dict__
}})
else:
g.db.api_settings.update(
{'_id': api_settings.get('_id')},
{'$set': {
'regions': [region.__dict__]
}})
flash('Region successfully added to system', 'success')
return redirect(
url_for('GlobalManageView:define_available_regions'))
else:
if request.method == 'POST':
flash(
'There was a form validation error, please '
'check the required values and try again.', 'error')
return render_template('manage/manage_regions.html',
form=form,
api_settings=api_settings)
def create_or_update_region(db_session,
region_name,
server_repositories,
created_by,
region=None):
"""
:param db_session:
:param name:
:param server_repositories:
assumes server_repositories is a comma-delimited string of valid server names that exist in CSM
:param region:
:return:
"""
region_name = check_acceptable_string(region_name)
if region is None:
region = Region(created_by=created_by)
db_session.add(region)
region.name = region_name
region.servers = []
if not is_empty(server_repositories):
for server_name in server_repositories.split(','):
valid_server = get_server(db_session, server_name.strip())
if valid_server is not None:
region.servers.append(valid_server)
else:
raise ValueNotFound(
"Server repository '{}' does not exist in the database.".
format(server_name))
db_session.commit()
return region
def ParseRegionDescriptions(data, image):
regions = []
for d in data:
regions.append(
Region(d['id'], image, d['phrase'], d['x'], d['y'], d['width'],
d['height']))
return regions
def define_available_regions(self):
settings = g.db.settings.find_one()
form = forms.RegionSet()
if request.method == 'POST' and form.validate_on_submit():
region = Region(request.form)
if region:
action, data = '$push', region.__dict__
if not settings.get('regions'):
action, data = '$set', [data]
g.db.settings.update({'_id': settings.get('_id')},
{action: {
'regions': data
}})
flash('Region successfully added to system', 'success')
return redirect(
url_for('ManagementView:define_available_regions'))
else:
if request.method == 'POST':
flash(
'There was a form validation error, please '
'check the required values and try again.', 'error')
return render_template('manage/manage_regions.html',
form=form,
settings=settings)
def read(self, data, app):
# ..
records = Region().all(app.dbpool)
# ..
return {
'records': records,
}
def create_annotation(form, object_name, labels, frame):
annotation = Region()
annotation.object_name = object_name
if form.cleaned_data['high_level']:
annotation.full_frame = True
annotation.x = 0
annotation.y = 0
annotation.h = 0
annotation.w = 0
else:
annotation.full_frame = False
annotation.x = form.cleaned_data['x']
annotation.y = form.cleaned_data['y']
annotation.h = form.cleaned_data['h']
annotation.w = form.cleaned_data['w']
annotation.metadata_text = form.cleaned_data['metadata_text']
annotation.metadata_json = form.cleaned_data['metadata_json']
annotation.frame = frame
annotation.video = frame.video
annotation.region_type = Region.ANNOTATION
annotation.save()
for l in labels:
if l.strip():
dl = AppliedLabel()
dl.video = annotation.video
dl.frame = annotation.frame
dl.region = annotation
dl.label_name = l.strip()
dl.source = dl.UI
dl.save()
def create_annotation(form, object_name, labels, frame):
annotation = Region()
annotation.object_name = object_name
if form.cleaned_data['high_level']:
annotation.full_frame = True
annotation.x = 0
annotation.y = 0
annotation.h = 0
annotation.w = 0
else:
annotation.full_frame = False
annotation.x = form.cleaned_data['x']
annotation.y = form.cleaned_data['y']
annotation.h = form.cleaned_data['h']
annotation.w = form.cleaned_data['w']
annotation.text = form.cleaned_data['text']
annotation.metadata = form.cleaned_data['metadata']
annotation.frame = frame
annotation.video = frame.video
annotation.region_type = Region.ANNOTATION
annotation.save()
for lname in labels:
if lname.strip():
dl, _ = Label.objects.get_or_create(name=lname, set="UI")
rl = RegionLabel()
rl.video = annotation.video
rl.frame = annotation.frame
rl.region = annotation
rl.label = dl
rl.save()
def import_region_json(r,
frame_index,
video_id,
event_id,
segment_index=None,
frame_id=None):
dr = Region()
dr.frame_index = frame_index
dr.video_id = video_id
dr.event_id = event_id
dr.object_name = r['object_name']
dr.region_type = r.get('region_type', Region.ANNOTATION)
dr.full_frame = r.get('full_frame', False)
if segment_index:
dr.segment_index = segment_index
if frame_id:
dr.frame_id = frame_id
dr.x = r.get('x', 0)
dr.y = r.get('y', 0)
dr.w = r.get('w', 0)
dr.h = r.get('h', 0)
dr.confidence = r.get('confidence', 0.0)
if r.get('text', None):
dr.text = r['text']
else:
dr.text = ""
dr.metadata = r.get('metadata', None)
return dr
def create_region(self, a):
da = Region()
da.video_id = self.video.pk
da.x = a['x']
da.y = a['y']
da.h = a['h']
da.w = a['w']
da.vdn_key = a['id']
if 'text' in a:
da.text = a['text']
elif 'metadata_text' in a:
da.text = a['metadata_text']
if 'metadata' in a:
da.metadata = a['metadata']
elif 'metadata_json' in a:
da.metadata = a['metadata_json']
da.materialized = a.get('materialized', False)
da.png = a.get('png', False)
da.region_type = a['region_type']
da.confidence = a['confidence']
da.object_name = a['object_name']
da.full_frame = a['full_frame']
if a.get('event', None):
da.event_id = self.event_to_pk[a['event']]
if 'parent_frame_index' in a:
da.frame_index = a['parent_frame_index']
else:
da.frame_index = a['frame_index']
if 'parent_segment_index' in a:
da.segment_index = a.get('parent_segment_index', -1)
else:
da.segment_index = a.get('segment_index', -1)
return da
def create_region(a,video_obj,vdn_dataset,event_to_pk=None):
da = Region()
da.video = video_obj
da.x = a['x']
da.y = a['y']
da.h = a['h']
da.w = a['w']
da.vdn_key = a['id']
if 'text' in a:
da.text = a['text']
elif 'metadata_text' in a:
da.text = a['metadata_text']
if 'metadata' in a:
da.metadata = a['metadata']
elif 'metadata_json' in a:
da.metadata = a['metadata_json']
da.materialized = a.get('materialized',False)
da.png = a.get('png',False)
da.region_type = a['region_type']
da.confidence = a['confidence']
da.object_name = a['object_name']
da.full_frame = a['full_frame']
if a.get('event',None):
da.event_id = event_to_pk[a['event']]
da.parent_frame_index = a['parent_frame_index']
da.parent_segment_index = a.get('parent_segment_index',-1)
if vdn_dataset:
da.vdn_dataset = vdn_dataset
return da
def ParseRegionDescriptions(data, image):
regions = []
if data[0].has_key('region_id'):
region_id_key = 'region_id'
else:
region_id_key = 'id'
for d in data:
regions.append(Region(d[region_id_key], image, d['phrase'], d['x'], d['y'], d['width'], d['height']))
return regions
def __init__(self, environ, start_fn):
super(CommentView, self).__init__(environ, start_fn)
self.context = {
'comment': Comment().as_dic(),
'regions': [r.as_dic() for r in Region().all()],
'warn': None,
'success': None,
}
def ajax(self):
"""
If XMLHttpRequest, geting all City() for region_id
and make json.dump()
"""
region_id = self.req_post.get('region_id', None)
if not region_id:
return "{}"
context = [
r.as_dic() for r in City().get(region=Region(id=region_id[0]))
]
return json.dumps(context)
def import_frame_regions_json(regions_json, video, event_id):
"""
Import regions from a JSON with frames identified by immuntable identifiers such as filename/path
:param regions_json:
:param video:
:param event_id:
:return:
"""
video_id = video.pk
filename_to_pk = {}
frame_index_to_pk = {}
if video.dataset:
# For dataset frames are identified by subdir/filename
filename_to_pk = {
df.original_path(): (df.pk, df.frame_index)
for df in Frame.objects.filter(video_id=video_id)
}
else:
# For videos frames are identified by frame index
frame_index_to_pk = {
df.frame_index: (df.pk, df.segment_index)
for df in Frame.objects.filter(video_id=video_id)
}
regions = []
for k in regions_json:
r = Region()
if k['target'] == 'filename':
fname = k['filename']
if not fname.startswith('/'):
fname = '/{}'.format(fname)
pk, findx = filename_to_pk[fname]
r.frame_id = pk
r.frame_index = findx
elif k['target'] == 'index':
pk, sindx = frame_index_to_pk[k['frame_index']]
r.frame_id = pk
r.frame_index = k['frame_index']
r.segment_index = sindx
else:
raise ValueError('invalid target: {}'.format(k['target']))
r.video_id = video_id
r.event_id = event_id
r.region_type = k['region_type']
r.materialized = k.get('materialized', False)
r.full_frame = k.get('full_frame', False)
r.x = k['x']
r.y = k['y']
r.w = k['w']
r.h = k['h']
r.metadata = k['metadata']
r.text = k['text']
Region.objects.bulk_create(regions, 1000)
def parse_region_descriptions(data, image):
"""
Helper to parse region descriptions.
"""
regions = []
if 'region_id' in data[0]:
region_id_key = 'region_id'
else:
region_id_key = 'id'
for info in data:
regions.append(
Region(info[region_id_key], image, info['phrase'], info['x'],
info['y'], info['width'], info['height']))
return regions
def writeRowToDB(row, constituencies):
if not emptyLine(row):
region_name = row[1]
region = None
if isState(row):
#state
region = Region(name=region_name)
db.session.add(region)
for constituency in constituencies:
region.constituencies.append(constituency)
db.session.add(constituency)
constituencies = []
else:
#constuency
region = Region(name=region_name)
constituencies.append(region)
writeVoteResultsToDB(row, region)
db.session.commit()
return constituencies
def add_region():
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
if g.user:
form = AddRegion()
if form.validate_on_submit():
region = Region(city=form.city.data,
county=form.county.data,
state=form.state.data)
db.session.add(region)
db.session.commit()
return redirect(f'/users/{g.user.id}/edit')
return render_template("region-form.html", form=form)
def wineRegionNew():
"""Create a new region"""
DBSession = open_db_session()
countries = DBSession.query(Country).order_by(asc(Country.name)).all()
if request.method == 'POST':
newRegion = Region(country_id=request.form['country_id'],
name=request.form['name'])
DBSession.add(newRegion)
DBSession.commit()
DBSession.close()
return redirect(url_for('wine_bp.wineCountriesRegions'))
else:
DBSession.close()
return render_template('countriesRegions.html')
def post(self):
"""
Сhecking that there are all an attributes
and they are correct for creating a comment,
if not, we return as is and a notification.
"""
def is_phone_valid(phone):
return re.match(r"^(\(\d+\))(\s)?\d+", phone)
def is_email_valid(email):
return re.match(r"[^@\s]+@[^@\s]+\.[a-zA-Z0-9]+$", email)
com = Comment()
if 'surname' in self.req_post:
com.surname = html.escape(self.req_post['surname'][0])
if 'firstname' in self.req_post:
com.firstname = html.escape(self.req_post['firstname'][0])
if 'patronymic' in self.req_post:
com.patronymic = html.escape(self.req_post['patronymic'][0])
if 'region' in self.req_post:
com.region = Region(id=int(self.req_post['region'][0]))
if 'city' in self.req_post:
com.city = City(id=int(self.req_post['city'][0]))
if 'phone' in self.req_post:
com.phone = html.escape(self.req_post['phone'][0])
if 'email' in self.req_post:
com.email = html.escape(self.req_post['email'][0])
if 'comment' in self.req_post:
com.comment = html.escape(self.req_post['comment'][0])
if not com.surname or not com.firstname or not com.comment:
self.context['warn'] = "You have required fields"
self.context['comment'] = com.as_dic()
return render('templates/comment.html', self.context)
if com.phone and not is_phone_valid(com.phone):
self.context['warn'] = "Invalid phone number format"
self.context['comment'] = com.as_dic()
return render('templates/comment.html', self.context)
if com.email and not is_email_valid(com.email):
self.context['warn'] = "Invalid email format"
self.context['comment'] = com.as_dic()
return render('templates/comment.html', self.context)
com.save()
self.context['success'] = "Comment has been added successfully"
return render('templates/comment.html', self.context)
def load_regions():
"""Load regions from CSV file into database."""
Region.query.delete()
with open('static/data/regions.csv', 'rb') as csvfile:
next(csvfile)
regions_reader = csv.reader(csvfile)
for row in regions_reader:
code = row[1]
name = row[3]
region = Region(code=code, name=name)
db.session.add(region)
db.session.commit()
def import_legacy_detection(d, video_obj, frame, vdn_dataset=None):
dd = Region()
dd.region_type = Region.DETECTION
dd.video = video_obj
dd.x = d['x']
dd.y = d['y']
dd.h = d['h']
dd.w = d['w']
dd.frame = frame
dd.confidence = d['confidence']
dd.object_name = d['object_name']
dd.metadata_json = d['metadata']
if vdn_dataset:
dd.vdn_dataset = dd.video.vdn_dataset
dd.vdn_key = d['id']
dd.save()
return dd
def setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
Steve1 = User.signup(username="******", password="******", first_name="steven", last_name="damouni", email="*****@*****.**")
Steveid1 = 1111
Steve1.id = Steveid1
genre1 = Genre(genre="classical")
genre1id = 1111
genre1.id = genre1id
region1 = Region(city="Seattle", county="King", state="Washington")
region1id = 1111
region1.id = region1id
instrument1 = Instrument(instrument="piano")
instrument1id = 1111
instrument1.id = instrument1id
db.session.add(genre1)
db.session.add(region1)
db.session.add(instrument1)
db.session.commit()
Steve1 = User.query.get(Steveid1)
genre1 = Genre.query.get(genre1id)
region1 = Region.query.get(region1id)
instrument1 = Instrument.query.get(instrument1id)
self.Steve1 = Steve1
self.Steveid1 = Steveid1
self.genre1 = genre1
self.genre1id = genre1id
self.region1 = region1
self.region1id = region1id
self.instrument1 = instrument1
self.instrument1id = instrument1id
self.client = app.test_client()
def create_region(self, a):
da = Region()
da.video_id = self.video.pk
da.x = a['x']
da.y = a['y']
da.h = a['h']
da.w = a['w']
da.text = a['text']
da.metadata = a['metadata']
da.png = a.get('png', False)
da.region_type = a['region_type']
da.confidence = a['confidence']
da.object_name = a['object_name']
da.full_frame = a['full_frame']
da.event_id = self.event_to_pk[a['event']]
da.frame_index = a['frame_index']
da.segment_index = a.get('segment_index', -1)
return da
def create_region(a, video_obj, vdn_dataset):
da = Region()
da.video = video_obj
da.x = a['x']
da.y = a['y']
da.h = a['h']
da.w = a['w']
da.vdn_key = a['id']
da.metadata_text = a['metadata_text']
da.metadata_json = a['metadata_json']
da.region_type = a['region_type']
da.confidence = a['confidence']
da.object_name = a['object_name']
da.full_frame = a['full_frame']
da.parent_frame_index = a['parent_frame_index']
if vdn_dataset:
da.vdn_dataset = vdn_dataset
return da
def _gen_zone(zone_name, latency, pricing, datacenters_map):
supported_cloud_providers = set({"aws", "gcp"})
zone_parts = zone_name.split("-")
if len(zone_parts) < 2:
print("Zone must be complete - ", zone_parts)
return None
cp_name = zone_parts[0]
if cp_name not in supported_cloud_providers:
print("Unsupported cloud provider - ", cp_name)
return None
cp = CloudProvider(cp_name)
region_name = "-".join(zone_parts[1:len(zone_parts)])
region_location = datacenters_map[cp_name + "-" + region_name]["location"]
region = Region(region_name, region_location)
zone = Zone("1", region, cp, latency, pricing[cp_name])
return zone
def populate_db(db_name):
exist_db = os.path.exists(db_name)
with connection(db_name) as conn:
with get_cursor(conn) as cursor:
if not exist_db:
with open('set_base.sql', 'rt') as set_base_script:
cursor.executescript(set_base_script.read())
if not exist_db:
with open('russian-subjects-master/native/regions.json',
'rt') as regions_json:
regions = json.loads(regions_json.read())
with open('russian-subjects-master/native/cities.json',
'rt') as cities_json:
cities = json.loads(cities_json.read())
for region_item in regions:
region = Region(name=region_item['name'], db_conn=conn).save()
for city_item in filter(
lambda each: each['region_id'] == region_item['id'],
cities):
City(name=city_item['name'], region=region,
db_conn=conn).save()
def create_annotation(form, object_name, labels, frame):
annotation = Region()
annotation.object_name = object_name
if form.cleaned_data['high_level']:
annotation.full_frame = True
annotation.x = 0
annotation.y = 0
annotation.h = 0
annotation.w = 0
else:
annotation.full_frame = False
annotation.x = form.cleaned_data['x']
annotation.y = form.cleaned_data['y']
annotation.h = form.cleaned_data['h']
annotation.w = form.cleaned_data['w']
annotation.text = form.cleaned_data['text']
annotation.metadata = form.cleaned_data['metadata']
annotation.frame = frame
annotation.video = frame.video
annotation.region_type = Region.ANNOTATION
annotation.save()
