repo_name stringlengths 5 100 | path stringlengths 4 294 | copies stringclasses 990 values | size stringlengths 4 7 | content stringlengths 666 1M | license stringclasses 15 values |
|---|---|---|---|---|---|
devendermishrajio/nova | nova/db/sqlalchemy/api_migrations/migrate_repo/versions/001_cell_mapping.py | 48 | 1798 | # Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from migrate import UniqueConstraint
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import Index
from sqlalchemy import Integer
from sqlalchemy import MetaData
from sqlalchemy import String
from sqlalchemy import Table
from sqlalchemy import Text
def upgrade(migrate_engine):
meta = MetaData()
meta.bind = migrate_engine
cell_mappings = Table('cell_mappings', meta,
Column('created_at', DateTime),
Column('updated_at', DateTime),
Column('id', Integer, primary_key=True, nullable=False),
Column('uuid', String(length=36), nullable=False),
Column('name', String(length=255)),
Column('transport_url', Text()),
Column('database_connection', Text()),
UniqueConstraint('uuid', name='uniq_cell_mappings0uuid'),
mysql_engine='InnoDB',
mysql_charset='utf8'
)
# NOTE(mriedem): DB2 creates an index when a unique constraint is created
# so trying to add a second index on the uuid column will fail with
# error SQL0605W, so omit the index in the case of DB2.
if migrate_engine.name != 'ibm_db_sa':
Index('uuid_idx', cell_mappings.c.uuid)
cell_mappings.create(checkfirst=True)
| apache-2.0 |
skoslowski/gnuradio | grc/gui/Notebook.py | 1 | 5710 | """
Copyright 2008, 2009, 2011 Free Software Foundation, Inc.
This file is part of GNU Radio
SPDX-License-Identifier: GPL-2.0-or-later
"""
from __future__ import absolute_import
import os
import logging
from gi.repository import Gtk, Gdk, GObject
from . import Actions
from .StateCache import StateCache
from .Constants import MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT
from .DrawingArea import DrawingArea
log = logging.getLogger(__name__)
class Notebook(Gtk.Notebook):
def __init__(self):
Gtk.Notebook.__init__(self)
log.debug("notebook()")
self.app = Gtk.Application.get_default()
self.current_page = None
self.set_show_border(False)
self.set_scrollable(True)
self.connect("switch-page", self._handle_page_change)
self.add_events(Gdk.EventMask.SCROLL_MASK)
self.connect("scroll-event", self._handle_scroll)
self._ignore_consecutive_scrolls = 0
def _handle_page_change(self, notebook, page, page_num):
"""
Handle a page change. When the user clicks on a new tab,
reload the flow graph to update the vars window and
call handle states (select nothing) to update the buttons.
Args:
notebook: the notebook
page: new page
page_num: new page number
"""
self.current_page = self.get_nth_page(page_num)
Actions.PAGE_CHANGE()
def _handle_scroll(self, widget, event):
# Not sure how to handle this at the moment.
natural = True
# Slow it down
if self._ignore_consecutive_scrolls == 0:
if event.direction in (Gdk.ScrollDirection.UP, Gdk.ScrollDirection.LEFT):
if natural:
self.prev_page()
else:
self.next_page()
elif event.direction in (
Gdk.ScrollDirection.DOWN,
Gdk.ScrollDirection.RIGHT,
):
if natural:
self.next_page()
else:
self.prev_page()
self._ignore_consecutive_scrolls = 3
else:
self._ignore_consecutive_scrolls -= 1
return False
class Page(Gtk.HBox):
"""A page in the notebook."""
def __init__(self, main_window, flow_graph, file_path=""):
"""
Page constructor.
Args:
main_window: main window
file_path: path to a flow graph file
"""
Gtk.HBox.__init__(self)
self.main_window = main_window
self.flow_graph = flow_graph
self.file_path = file_path
self.process = None
self.saved = True
# import the file
initial_state = flow_graph.parent_platform.parse_flow_graph(file_path)
flow_graph.import_data(initial_state)
self.state_cache = StateCache(initial_state)
# tab box to hold label and close button
self.label = Gtk.Label()
image = Gtk.Image.new_from_icon_name("window-close", Gtk.IconSize.MENU)
image_box = Gtk.HBox(homogeneous=False, spacing=0)
image_box.pack_start(image, True, False, 0)
button = Gtk.Button()
button.connect("clicked", self._handle_button)
button.set_relief(Gtk.ReliefStyle.NONE)
button.add(image_box)
tab = self.tab = Gtk.HBox(homogeneous=False, spacing=0)
tab.pack_start(self.label, False, False, 0)
tab.pack_start(button, False, False, 0)
tab.show_all()
# setup scroll window and drawing area
self.drawing_area = DrawingArea(flow_graph)
flow_graph.drawing_area = self.drawing_area
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_size_request(MIN_WINDOW_WIDTH, MIN_WINDOW_HEIGHT)
self.scrolled_window.set_policy(Gtk.PolicyType.ALWAYS, Gtk.PolicyType.ALWAYS)
self.scrolled_window.connect(
"key-press-event", self._handle_scroll_window_key_press
)
self.scrolled_window.add(self.drawing_area)
self.pack_start(self.scrolled_window, True, True, 0)
self.show_all()
def _handle_scroll_window_key_press(self, widget, event):
is_ctrl_pg = event.state & Gdk.ModifierType.CONTROL_MASK and event.keyval in (
Gdk.KEY_Page_Up,
Gdk.KEY_Page_Down,
)
if is_ctrl_pg:
return self.get_parent().event(event)
def get_generator(self):
"""
Get the generator object for this flow graph.
Returns:
generator
"""
platform = self.flow_graph.parent_platform
return platform.Generator(self.flow_graph, os.path.dirname(self.file_path))
def _handle_button(self, button):
"""
The button was clicked.
Make the current page selected, then close.
Args:
the: button
"""
self.main_window.page_to_be_closed = self
Actions.FLOW_GRAPH_CLOSE()
def set_markup(self, markup):
"""
Set the markup in this label.
Args:
markup: the new markup text
"""
self.label.set_markup(markup)
def set_tooltip(self, text):
"""
Set the tooltip text in this label.
Args:
text: the new tooltip text
"""
self.label.set_tooltip_text(text)
def get_read_only(self):
"""
Get the read-only state of the file.
Always false for empty path.
Returns:
true for read-only
"""
if not self.file_path:
return False
return os.path.exists(self.file_path) and not os.access(self.file_path, os.W_OK)
| gpl-3.0 |
mrquim/mrquimrepo | plugin.video.castaway/resources/lib/modules/client.py | 6 | 13409 | # -*- coding: utf-8 -*-
'''
Exodus Add-on
Copyright (C) 2016 Exodus
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
import re,sys,cookielib,urllib,urllib2,urlparse,HTMLParser,time,random
import cache
def request(url, close=True, redirect=True, error=False, proxy=None, post=None, headers=None, mobile=False, limit=None, referer=None, cookie=None,cj = None, output='', timeout='30'):
try:
handlers = []
if not proxy == None:
handlers += [urllib2.ProxyHandler({'http':'%s' % (proxy)}), urllib2.HTTPHandler]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
if output == 'cookie' or output == 'extended' or output=='cj' or not close == True:
if not cj==None:
cookies = cookielib.LWPCookieJar()
else:
cookies = cj
handlers += [urllib2.HTTPHandler(), urllib2.HTTPSHandler(), urllib2.HTTPCookieProcessor(cookies)]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
try:
if sys.version_info < (2, 7, 9): raise Exception()
import ssl; ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
handlers += [urllib2.HTTPSHandler(context=ssl_context)]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
except:
pass
try: headers.update(headers)
except: headers = {}
if 'User-Agent' in headers:
pass
elif not mobile == True:
#headers['User-Agent'] = agent()
headers['User-Agent'] = cache.get(randomagent, 1)
else:
headers['User-Agent'] = 'Apple-iPhone/701.341'
if 'Referer' in headers:
pass
elif referer == None:
headers['Referer'] = '%s://%s/' % (urlparse.urlparse(url).scheme, urlparse.urlparse(url).netloc)
else:
headers['Referer'] = referer
if not 'Accept-Language' in headers:
headers['Accept-Language'] = 'en-US'
if 'Cookie' in headers:
pass
elif not cookie == None:
headers['Cookie'] = cookie
if redirect == False:
class NoRedirection(urllib2.HTTPErrorProcessor):
def http_response(self, request, response): return response
opener = urllib2.build_opener(NoRedirection)
opener = urllib2.install_opener(opener)
try: del headers['Referer']
except: pass
request = urllib2.Request(url, data=post, headers=headers)
try:
response = urllib2.urlopen(request, timeout=int(timeout))
except urllib2.HTTPError as response:
if response.code == 503:
if 'cf-browser-verification' in response.read(5242880):
netloc = '%s://%s' % (urlparse.urlparse(url).scheme, urlparse.urlparse(url).netloc)
cf = cache.get(cfcookie, 168, netloc, headers['User-Agent'], timeout)
headers['Cookie'] = cf
request = urllib2.Request(url, data=post, headers=headers)
response = urllib2.urlopen(request, timeout=int(timeout))
elif error == False:
return
elif error == False:
return
if output == 'cookie':
try: result = '; '.join(['%s=%s' % (i.name, i.value) for i in cookies])
except: pass
try: result = cf
except: pass
elif output=='cj':
result = cookies
elif output == 'response':
if limit == '0':
result = (str(response.code), response.read(224 * 1024))
elif not limit == None:
result = (str(response.code), response.read(int(limit) * 1024))
else:
result = (str(response.code), response.read(5242880))
elif output == 'chunk':
try: content = int(response.headers['Content-Length'])
except: content = (2049 * 1024)
if content < (2048 * 1024): return
result = response.read(16 * 1024)
elif output == 'extended':
try: cookie = '; '.join(['%s=%s' % (i.name, i.value) for i in cookies])
except: pass
try: cookie = cf
except: pass
content = response.headers
result = response.read(5242880)
return (result, headers, content, cookie)
elif output == 'geturl':
result = response.geturl()
elif output == 'cj':
result = cookies
elif output == 'headers':
content = response.headers
return content
else:
if limit == '0':
result = response.read(224 * 1024)
elif not limit == None:
result = response.read(int(limit) * 1024)
else:
result = response.read(5242880)
if close == True:
response.close()
return result
except:
return
def parseDOM(html, name=u"", attrs={}, ret=False):
# Copyright (C) 2010-2011 Tobias Ussing And Henrik Mosgaard Jensen
if isinstance(html, str):
try:
html = [html.decode("utf-8")]
except:
html = [html]
elif isinstance(html, unicode):
html = [html]
elif not isinstance(html, list):
return u""
if not name.strip():
return u""
ret_lst = []
for item in html:
temp_item = re.compile('(<[^>]*?\n[^>]*?>)').findall(item)
for match in temp_item:
item = item.replace(match, match.replace("\n", " "))
lst = []
for key in attrs:
lst2 = re.compile('(<' + name + '[^>]*?(?:' + key + '=[\'"]' + attrs[key] + '[\'"].*?>))', re.M | re.S).findall(item)
if len(lst2) == 0 and attrs[key].find(" ") == -1:
lst2 = re.compile('(<' + name + '[^>]*?(?:' + key + '=' + attrs[key] + '.*?>))', re.M | re.S).findall(item)
if len(lst) == 0:
lst = lst2
lst2 = []
else:
test = range(len(lst))
test.reverse()
for i in test:
if not lst[i] in lst2:
del(lst[i])
if len(lst) == 0 and attrs == {}:
lst = re.compile('(<' + name + '>)', re.M | re.S).findall(item)
if len(lst) == 0:
lst = re.compile('(<' + name + ' .*?>)', re.M | re.S).findall(item)
if isinstance(ret, str):
lst2 = []
for match in lst:
attr_lst = re.compile('<' + name + '.*?' + ret + '=([\'"].[^>]*?[\'"])>', re.M | re.S).findall(match)
if len(attr_lst) == 0:
attr_lst = re.compile('<' + name + '.*?' + ret + '=(.[^>]*?)>', re.M | re.S).findall(match)
for tmp in attr_lst:
cont_char = tmp[0]
if cont_char in "'\"":
if tmp.find('=' + cont_char, tmp.find(cont_char, 1)) > -1:
tmp = tmp[:tmp.find('=' + cont_char, tmp.find(cont_char, 1))]
if tmp.rfind(cont_char, 1) > -1:
tmp = tmp[1:tmp.rfind(cont_char)]
else:
if tmp.find(" ") > 0:
tmp = tmp[:tmp.find(" ")]
elif tmp.find("/") > 0:
tmp = tmp[:tmp.find("/")]
elif tmp.find(">") > 0:
tmp = tmp[:tmp.find(">")]
lst2.append(tmp.strip())
lst = lst2
else:
lst2 = []
for match in lst:
endstr = u"</" + name
start = item.find(match)
end = item.find(endstr, start)
pos = item.find("<" + name, start + 1 )
while pos < end and pos != -1:
tend = item.find(endstr, end + len(endstr))
if tend != -1:
end = tend
pos = item.find("<" + name, pos + 1)
if start == -1 and end == -1:
temp = u""
elif start > -1 and end > -1:
temp = item[start + len(match):end]
elif end > -1:
temp = item[:end]
elif start > -1:
temp = item[start + len(match):]
if ret:
endstr = item[end:item.find(">", item.find(endstr)) + 1]
temp = match + temp + endstr
item = item[item.find(temp, item.find(match)) + len(temp):]
lst2.append(temp)
lst = lst2
ret_lst += lst
return ret_lst
def replaceHTMLCodes(txt):
txt = re.sub("(&#[0-9]+)([^;^0-9]+)", "\\1;\\2", txt)
txt = HTMLParser.HTMLParser().unescape(txt)
txt = txt.replace(""", "\"")
txt = txt.replace("&", "&")
return txt
def randomagent():
BR_VERS = [
['%s.0' % i for i in xrange(18, 43)],
['37.0.2062.103', '37.0.2062.120', '37.0.2062.124', '38.0.2125.101', '38.0.2125.104', '38.0.2125.111', '39.0.2171.71', '39.0.2171.95', '39.0.2171.99', '40.0.2214.93', '40.0.2214.111',
'40.0.2214.115', '42.0.2311.90', '42.0.2311.135', '42.0.2311.152', '43.0.2357.81', '43.0.2357.124', '44.0.2403.155', '44.0.2403.157', '45.0.2454.101', '45.0.2454.85', '46.0.2490.71',
'46.0.2490.80', '46.0.2490.86', '47.0.2526.73', '47.0.2526.80'],
['11.0']]
WIN_VERS = ['Windows NT 10.0', 'Windows NT 7.0', 'Windows NT 6.3', 'Windows NT 6.2', 'Windows NT 6.1', 'Windows NT 6.0', 'Windows NT 5.1', 'Windows NT 5.0']
FEATURES = ['; WOW64', '; Win64; IA64', '; Win64; x64', '']
RAND_UAS = ['Mozilla/5.0 ({win_ver}{feature}; rv:{br_ver}) Gecko/20100101 Firefox/{br_ver}',
'Mozilla/5.0 ({win_ver}{feature}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{br_ver} Safari/537.36',
'Mozilla/5.0 ({win_ver}{feature}; Trident/7.0; rv:{br_ver}) like Gecko']
index = random.randrange(len(RAND_UAS))
return RAND_UAS[index].format(win_ver=random.choice(WIN_VERS), feature=random.choice(FEATURES), br_ver=random.choice(BR_VERS[index]))
def agent():
return cache.get(randomagent, 1)
def mobile_agent():
return 'Apple-iPhone/701.341'
def cfcookie(netloc, ua, timeout):
try:
headers = {'User-Agent': ua}
request = urllib2.Request(netloc, headers=headers)
try:
response = urllib2.urlopen(request, timeout=int(timeout))
except urllib2.HTTPError as response:
result = response.read(5242880)
jschl = re.findall('name="jschl_vc" value="(.+?)"/>', result)[0]
init = re.findall('setTimeout\(function\(\){\s*.*?.*:(.*?)};', result)[-1]
builder = re.findall(r"challenge-form\'\);\s*(.*)a.v", result)[0]
decryptVal = parseJSString(init)
lines = builder.split(';')
for line in lines:
if len(line) > 0 and '=' in line:
sections=line.split('=')
line_val = parseJSString(sections[1])
decryptVal = int(eval(str(decryptVal)+sections[0][-1]+str(line_val)))
answer = decryptVal + len(urlparse.urlparse(netloc).netloc)
query = '%s/cdn-cgi/l/chk_jschl?jschl_vc=%s&jschl_answer=%s' % (netloc, jschl, answer)
if 'type="hidden" name="pass"' in result:
passval = re.findall('name="pass" value="(.*?)"', result)[0]
query = '%s/cdn-cgi/l/chk_jschl?pass=%s&jschl_vc=%s&jschl_answer=%s' % (netloc, urllib.quote_plus(passval), jschl, answer)
time.sleep(5)
cookies = cookielib.LWPCookieJar()
handlers = [urllib2.HTTPHandler(), urllib2.HTTPSHandler(), urllib2.HTTPCookieProcessor(cookies)]
opener = urllib2.build_opener(*handlers)
opener = urllib2.install_opener(opener)
try:
request = urllib2.Request(query, headers=headers)
response = urllib2.urlopen(request, timeout=int(timeout))
except:
pass
cookie = '; '.join(['%s=%s' % (i.name, i.value) for i in cookies])
return cookie
except:
pass
def parseJSString(s):
try:
offset=1 if s[0]=='+' else 0
val = int(eval(s.replace('!+[]','1').replace('!![]','1').replace('[]','0').replace('(','str(')[offset:]))
return val
except:
pass
| gpl-2.0 |
foreni-packages/golismero | golismero/api/data/resource/__init__.py | 8 | 1307 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Resource types.
"""
__license__ = """
GoLismero 2.0 - The web knife - Copyright (C) 2011-2014
Authors:
Daniel Garcia Garcia a.k.a cr0hn | cr0hn@cr0hn.com
Mario Vilas | mvilas@gmail.com
Golismero project site: https://github.com/golismero
Golismero project mail: contact@golismero-project.com
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
"""
__all__ = ["Resource"]
from .. import Data
#------------------------------------------------------------------------------
class Resource(Data):
"""
Base class for resources.
"""
data_type = Data.TYPE_RESOURCE
data_subtype = "resource/abstract"
| gpl-2.0 |
Niknakflak/-tg-station | SQL/ban_conversion_2018-10-28.py | 51 | 9890 | #Python 3+ Script for converting ban table format as of 2018-10-28 made by Jordie0608
#
#Before starting ensure you have installed the mysqlclient package https://github.com/PyMySQL/mysqlclient-python
#It can be downloaded from command line with pip:
#pip install mysqlclient
#
#You will also have to create a new ban table for inserting converted data to per the schema:
#CREATE TABLE `ban` (
# `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
# `bantime` DATETIME NOT NULL,
# `server_ip` INT(10) UNSIGNED NOT NULL,
# `server_port` SMALLINT(5) UNSIGNED NOT NULL,
# `round_id` INT(11) UNSIGNED NOT NULL,
# `role` VARCHAR(32) NULL DEFAULT NULL,
# `expiration_time` DATETIME NULL DEFAULT NULL,
# `applies_to_admins` TINYINT(1) UNSIGNED NOT NULL DEFAULT '0',
# `reason` VARCHAR(2048) NOT NULL,
# `ckey` VARCHAR(32) NULL DEFAULT NULL,
# `ip` INT(10) UNSIGNED NULL DEFAULT NULL,
# `computerid` VARCHAR(32) NULL DEFAULT NULL,
# `a_ckey` VARCHAR(32) NOT NULL,
# `a_ip` INT(10) UNSIGNED NOT NULL,
# `a_computerid` VARCHAR(32) NOT NULL,
# `who` VARCHAR(2048) NOT NULL,
# `adminwho` VARCHAR(2048) NOT NULL,
# `edits` TEXT NULL DEFAULT NULL,
# `unbanned_datetime` DATETIME NULL DEFAULT NULL,
# `unbanned_ckey` VARCHAR(32) NULL DEFAULT NULL,
# `unbanned_ip` INT(10) UNSIGNED NULL DEFAULT NULL,
# `unbanned_computerid` VARCHAR(32) NULL DEFAULT NULL,
# `unbanned_round_id` INT(11) UNSIGNED NULL DEFAULT NULL,
# PRIMARY KEY (`id`),
# KEY `idx_ban_isbanned` (`ckey`,`role`,`unbanned_datetime`,`expiration_time`),
# KEY `idx_ban_isbanned_details` (`ckey`,`ip`,`computerid`,`role`,`unbanned_datetime`,`expiration_time`),
# KEY `idx_ban_count` (`bantime`,`a_ckey`,`applies_to_admins`,`unbanned_datetime`,`expiration_time`)
#) ENGINE=InnoDB DEFAULT CHARSET=latin1;
#This is to prevent the destruction of existing data and allow rollbacks to be performed in the event of an error during conversion
#Once conversion is complete remember to rename the old and new ban tables; it's up to you if you want to keep the old table
#
#To view the parameters for this script, execute it with the argument --help
#All the positional arguments are required, remember to include prefixes in your table names if you use them
#An example of the command used to execute this script from powershell:
#python ban_conversion_2018-10-28.py "localhost" "root" "password" "feedback" "SS13_ban" "SS13_ban_new"
#I found that this script would complete conversion of 35000 rows in approximately 20 seconds, results will depend on the size of your ban table and computer used
#
#The script has been tested to complete with tgstation's ban table as of 2018-09-02 02:19:56
#In the event of an error the new ban table is automatically truncated
#The source table is never modified so you don't have to worry about losing any data due to errors
#Some additional error correction is performed to fix problems specific to legacy and invalid data in tgstation's ban table, these operations are tagged with a 'TG:' comment
#Even if you don't have any of these specific problems in your ban table the operations won't have matter as they have an insignificant effect on runtime
#
#While this script is safe to run with your game server(s) active, any bans created after the script has started won't be converted
#You will also have to ensure that the code and table names are updated between rounds as neither will be compatible
import MySQLdb
import argparse
import sys
from datetime import datetime
def parse_role(bantype, job):
if bantype in ("PERMABAN", "TEMPBAN", "ADMIN_PERMABAN", "ADMIN_TEMPBAN"):
role = "Server"
else:
#TG: Some legacy jobbans are missing the last character from their job string.
job_name_fixes = {"A":"AI", "Captai":"Captain", "Cargo Technicia":"Cargo Technician", "Chaplai":"Chaplain", "Che":"Chef", "Chemis":"Chemist", "Chief Enginee":"Chief Engineer", "Chief Medical Office":"Chief Medical Officer", "Cybor":"Cyborg", "Detectiv":"Detective", "Head of Personne":"Head of Personnel", "Head of Securit":"Head of Security", "Mim":"Mime", "pA":"pAI", "Quartermaste":"Quartermaster", "Research Directo":"Research Director", "Scientis":"Scientist", "Security Office":"Security Officer", "Station Enginee":"Station Engineer", "Syndicat":"Syndicate", "Warde":"Warden"}
keep_job_names = ("AI", "Head of Personnel", "Head of Security", "OOC", "pAI")
if job in job_name_fixes:
role = job_name_fixes[job]
#Some job names we want to keep the same as .title() would return a different string.
elif job in keep_job_names:
role = job
#And then there's this asshole.
elif job == "servant of Ratvar":
role = "Servant of Ratvar"
else:
role = job.title()
return role
def parse_admin(bantype):
if bantype in ("ADMIN_PERMABAN", "ADMIN_TEMPBAN"):
return 1
else:
return 0
def parse_datetime(bantype, expiration_time):
if bantype in ("PERMABAN", "JOB_PERMABAN", "ADMIN_PERMABAN"):
expiration_time = None
#TG: two bans with an invalid expiration_time due to admins setting the duration to approx. 19 billion years, I'm going to count them as permabans.
elif expiration_time == "0000-00-00 00:00:00":
expiration_time = None
elif not expiration_time:
expiration_time = None
return expiration_time
def parse_not_null(field):
if not field:
field = 0
return field
def parse_for_empty(field):
if not field:
field = None
#TG: Several bans from 2012, probably from clients disconnecting while a ban was being made.
elif field == "BLANK CKEY ERROR":
field = None
return field
if sys.version_info[0] < 3:
raise Exception("Python must be at least version 3 for this script.")
current_round = 0
parser = argparse.ArgumentParser()
parser.add_argument("address", help="MySQL server address (use localhost for the current computer)")
parser.add_argument("username", help="MySQL login username")
parser.add_argument("password", help="MySQL login username")
parser.add_argument("database", help="Database name")
parser.add_argument("curtable", help="Name of the current ban table (remember prefixes if you use them)")
parser.add_argument("newtable", help="Name of the new table to insert to, can't be same as the source table (remember prefixes)")
args = parser.parse_args()
db=MySQLdb.connect(host=args.address, user=args.username, passwd=args.password, db=args.database)
cursor=db.cursor()
current_table = args.curtable
new_table = args.newtable
#TG: Due to deleted rows and a legacy ban import being inserted from id 3140 id order is not contiguous or in line with date order. While technically valid, it's confusing and I don't like that.
#TG: So instead of just running through to MAX(id) we're going to reorder the records by bantime as we go.
cursor.execute("SELECT id FROM " + current_table + " ORDER BY bantime ASC")
id_list = cursor.fetchall()
start_time = datetime.now()
print("Beginning conversion at {0}".format(start_time.strftime("%Y-%m-%d %H:%M:%S")))
try:
for current_id in id_list:
if current_id[0] % 5000 == 0:
cur_time = datetime.now()
print("Reached row ID {0} Duration: {1}".format(current_id[0], cur_time - start_time))
cursor.execute("SELECT * FROM " + current_table + " WHERE id = %s", [current_id[0]])
query_row = cursor.fetchone()
if not query_row:
continue
else:
#TG: bans with an empty reason which were somehow created with almost every field being null or empty, we can't do much but skip this
if not query_row[6]:
continue
bantime = query_row[1]
server_ip = query_row[2]
server_port = query_row[3]
round_id = query_row[4]
applies_to_admins = parse_admin(query_row[5])
reason = query_row[6]
role = parse_role(query_row[5], query_row[7])
expiration_time = parse_datetime(query_row[5], query_row[9])
ckey = parse_for_empty(query_row[10])
computerid = parse_for_empty(query_row[11])
ip = parse_for_empty(query_row[12])
a_ckey = parse_not_null(query_row[13])
a_computerid = parse_not_null(query_row[14])
a_ip = parse_not_null(query_row[15])
who = query_row[16]
adminwho = query_row[17]
edits = parse_for_empty(query_row[18])
unbanned_datetime = parse_datetime(None, query_row[20])
unbanned_ckey = parse_for_empty(query_row[21])
unbanned_computerid = parse_for_empty(query_row[22])
unbanned_ip = parse_for_empty(query_row[23])
cursor.execute("INSERT INTO " + new_table + " (bantime, server_ip, server_port, round_id, role, expiration_time, applies_to_admins, reason, ckey, ip, computerid, a_ckey, a_ip, a_computerid, who, adminwho, edits, unbanned_datetime, unbanned_ckey, unbanned_ip, unbanned_computerid) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", (bantime, server_ip, server_port, round_id, role, expiration_time, applies_to_admins, reason, ckey, ip, computerid, a_ckey, a_ip, a_computerid, who, adminwho, edits, unbanned_datetime, unbanned_ckey, unbanned_ip, unbanned_computerid))
db.commit()
end_time = datetime.now()
print("Conversion completed at {0}".format(datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
print("Script duration: {0}".format(end_time - start_time))
except Exception as e:
end_time = datetime.now()
print("Error encountered on row ID {0} at {1}".format(current_id[0], datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
print("Script duration: {0}".format(end_time - start_time))
cursor.execute("TRUNCATE {0} ".format(new_table))
raise e
cursor.close()
| agpl-3.0 |
LingxiaoJIA/gem5 | configs/example/read_config.py | 21 | 19305 | # Copyright (c) 2014 ARM Limited
# All rights reserved.
#
# The license below extends only to copyright in the software and shall
# not be construed as granting a license to any other intellectual
# property including but not limited to intellectual property relating
# to a hardware implementation of the functionality of the software
# licensed hereunder. You may use the software subject to the license
# terms below provided that you ensure that this notice is replicated
# unmodified and in its entirety in all distributions of the software,
# modified or unmodified, in source code or in binary form.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Author: Andrew Bardsley
# This script allows .ini and .json system config file generated from a
# previous gem5 run to be read in and instantiated.
#
# This may be useful as a way of allowing variant run scripts (say,
# with more complicated than usual checkpointing/stats dumping/
# simulation control) to read pre-described systems from config scripts
# with better system-description capabilities. Splitting scripts
# between system construction and run control may allow better
# debugging.
import argparse
import ConfigParser
import inspect
import json
import re
import sys
import m5
import m5.ticks as ticks
sim_object_classes_by_name = {
cls.__name__: cls for cls in m5.objects.__dict__.itervalues()
if inspect.isclass(cls) and issubclass(cls, m5.objects.SimObject) }
# Add some parsing functions to Param classes to handle reading in .ini
# file elements. This could be moved into src/python/m5/params.py if
# reading .ini files from Python proves to be useful
def no_parser(cls, flags, param):
raise Exception('Can\'t parse string: %s for parameter'
' class: %s' % (str(param), cls.__name__))
def simple_parser(suffix='', cast=lambda i: i):
def body(cls, flags, param):
return cls(cast(param + suffix))
return body
# def tick_parser(cast=m5.objects.Latency): # lambda i: i):
def tick_parser(cast=lambda i: i):
def body(cls, flags, param):
old_param = param
ret = cls(cast(str(param) + 't'))
return ret
return body
def addr_range_parser(cls, flags, param):
sys.stdout.flush()
low, high = param.split(':')
return m5.objects.AddrRange(long(low), long(high))
def memory_bandwidth_parser(cls, flags, param):
# The string will be in tick/byte
# Convert to byte/tick
value = 1.0 / float(param)
# Convert to byte/s
value = ticks.fromSeconds(value)
return cls('%fB/s' % value)
# These parameters have trickier parsing from .ini files than might be
# expected
param_parsers = {
'Bool': simple_parser(),
'ParamValue': no_parser,
'NumericParamValue': simple_parser(cast=long),
'TickParamValue': tick_parser(),
'Frequency': tick_parser(cast=m5.objects.Latency),
'Voltage': simple_parser(suffix='V'),
'Enum': simple_parser(),
'MemorySize': simple_parser(suffix='B'),
'MemorySize32': simple_parser(suffix='B'),
'AddrRange': addr_range_parser,
'String': simple_parser(),
'MemoryBandwidth': memory_bandwidth_parser,
'Time': simple_parser()
}
for name, parser in param_parsers.iteritems():
setattr(m5.params.__dict__[name], 'parse_ini', classmethod(parser))
class PortConnection(object):
"""This class is similar to m5.params.PortRef but with just enough
information for ConfigManager"""
def __init__(self, object_name, port_name, index):
self.object_name = object_name
self.port_name = port_name
self.index = index
@classmethod
def from_string(cls, str):
m = re.match('(.*)\.([^.\[]+)(\[(\d+)\])?', str)
object_name, port_name, whole_index, index = m.groups()
if index is not None:
index = int(index)
else:
index = 0
return PortConnection(object_name, port_name, index)
def __str__(self):
return '%s.%s[%d]' % (self.object_name, self.port_name, self.index)
def __cmp__(self, right):
return cmp((self.object_name, self.port_name, self.index),
(right.object_name, right.port_name, right.index))
def to_list(v):
"""Convert any non list to a singleton list"""
if isinstance(v, list):
return v
else:
return [v]
class ConfigManager(object):
"""Manager for parsing a Root configuration from a config file"""
def __init__(self, config):
self.config = config
self.objects_by_name = {}
self.flags = config.get_flags()
def find_object(self, object_name):
"""Find and configure (with just non-SimObject parameters)
a single object"""
if object_name == 'Null':
return NULL
if object_name in self.objects_by_name:
return self.objects_by_name[object_name]
object_type = self.config.get_param(object_name, 'type')
if object_type not in sim_object_classes_by_name:
raise Exception('No SimObject type %s is available to'
' build: %s' % (object_type, object_name))
object_class = sim_object_classes_by_name[object_type]
parsed_params = {}
for param_name, param in object_class._params.iteritems():
if issubclass(param.ptype, m5.params.ParamValue):
if isinstance(param, m5.params.VectorParamDesc):
param_values = self.config.get_param_vector(object_name,
param_name)
param_value = [ param.ptype.parse_ini(self.flags, value)
for value in param_values ]
else:
param_value = param.ptype.parse_ini(
self.flags, self.config.get_param(object_name,
param_name))
parsed_params[param_name] = param_value
obj = object_class(**parsed_params)
self.objects_by_name[object_name] = obj
return obj
def fill_in_simobj_parameters(self, object_name, obj):
"""Fill in all references to other SimObjects in an objects
parameters. This relies on all referenced objects having been
created"""
if object_name == 'Null':
return NULL
for param_name, param in obj.__class__._params.iteritems():
if issubclass(param.ptype, m5.objects.SimObject):
if isinstance(param, m5.params.VectorParamDesc):
param_values = self.config.get_param_vector(object_name,
param_name)
setattr(obj, param_name, [ self.objects_by_name[name]
for name in param_values ])
else:
param_value = self.config.get_param(object_name,
param_name)
if param_value != 'Null':
setattr(obj, param_name, self.objects_by_name[
param_value])
return obj
def fill_in_children(self, object_name, obj):
"""Fill in the children of this object. This relies on all the
referenced objects having been created"""
children = self.config.get_object_children(object_name)
for child_name, child_paths in children:
param = obj.__class__._params.get(child_name, None)
if isinstance(child_paths, list):
child_list = [ self.objects_by_name[path]
for path in child_paths ]
else:
child_list = self.objects_by_name[child_paths]
obj.add_child(child_name, child_list)
for path in to_list(child_paths):
self.fill_in_children(path, self.objects_by_name[path])
return obj
def parse_port_name(self, port):
"""Parse the name of a port"""
m = re.match('(.*)\.([^.\[]+)(\[(\d+)\])?', port)
peer, peer_port, whole_index, index = m.groups()
if index is not None:
index = int(index)
else:
index = 0
return (peer, self.objects_by_name[peer], peer_port, index)
def gather_port_connections(self, object_name, obj):
"""Gather all the port-to-port connections from the named object.
Returns a list of (PortConnection, PortConnection) with unordered
(wrt. master/slave) connection information"""
if object_name == 'Null':
return NULL
parsed_ports = []
for port_name, port in obj.__class__._ports.iteritems():
# Assume that unnamed ports are unconnected
peers = self.config.get_port_peers(object_name, port_name)
for index, peer in zip(xrange(0, len(peers)), peers):
parsed_ports.append((
PortConnection(object_name, port.name, index),
PortConnection.from_string(peer)))
return parsed_ports
def bind_ports(self, connections):
"""Bind all ports from the given connection list. Note that the
connection list *must* list all connections with both (slave,master)
and (master,slave) orderings"""
# Markup a dict of how many connections are made to each port.
# This will be used to check that the next-to-be-made connection
# has a suitable port index
port_bind_indices = {}
for from_port, to_port in connections:
port_bind_indices[
(from_port.object_name, from_port.port_name)] = 0
def port_has_correct_index(port):
return port_bind_indices[
(port.object_name, port.port_name)] == port.index
def increment_port_index(port):
port_bind_indices[
(port.object_name, port.port_name)] += 1
# Step through the sorted connections. Exactly one of
# each (slave,master) and (master,slave) pairs will be
# bindable because the connections are sorted.
# For example: port_bind_indices
# left right left right
# a.b[0] -> d.f[1] 0 0 X
# a.b[1] -> e.g 0 0 BIND!
# e.g -> a.b[1] 1 X 0
# d.f[0] -> f.h 0 0 BIND!
# d.f[1] -> a.b[0] 1 0 BIND!
connections_to_make = []
for connection in sorted(connections):
from_port, to_port = connection
if (port_has_correct_index(from_port) and
port_has_correct_index(to_port)):
connections_to_make.append((from_port, to_port))
increment_port_index(from_port)
increment_port_index(to_port)
# Exactly half of the connections (ie. all of them, one per
# direction) must now have been made
if (len(connections_to_make) * 2) != len(connections):
raise Exception('Port bindings can\'t be ordered')
# Actually do the binding
for from_port, to_port in connections_to_make:
from_object = self.objects_by_name[from_port.object_name]
to_object = self.objects_by_name[to_port.object_name]
setattr(from_object, from_port.port_name,
getattr(to_object, to_port.port_name))
def find_all_objects(self):
"""Find and build all SimObjects from the config file and connect
their ports together as described. Does not instantiate system"""
# Build SimObjects for all sections of the config file
# populating not-SimObject-valued parameters
for object_name in self.config.get_all_object_names():
self.find_object(object_name)
# Add children to objects in the hierarchy from root
self.fill_in_children('root', self.find_object('root'))
# Now fill in SimObject-valued parameters in the knowledge that
# this won't be interpreted as becoming the parent of objects
# which are already in the root hierarchy
for name, obj in self.objects_by_name.iteritems():
self.fill_in_simobj_parameters(name, obj)
# Gather a list of all port-to-port connections
connections = []
for name, obj in self.objects_by_name.iteritems():
connections += self.gather_port_connections(name, obj)
# Find an acceptable order to bind those port connections and
# bind them
self.bind_ports(connections)
class ConfigFile(object):
def get_flags(self):
return set()
def load(self, config_file):
"""Load the named config file"""
pass
def get_all_object_names(self):
"""Get a list of all the SimObject paths in the configuration"""
pass
def get_param(self, object_name, param_name):
"""Get a single param or SimObject reference from the configuration
as a string"""
pass
def get_param_vector(self, object_name, param_name):
"""Get a vector param or vector of SimObject references from the
configuration as a list of strings"""
pass
def get_object_children(self, object_name):
"""Get a list of (name, paths) for each child of this object.
paths is either a single string object path or a list of object
paths"""
pass
def get_port_peers(self, object_name, port_name):
"""Get the list of connected port names (in the string form
object.port(\[index\])?) of the port object_name.port_name"""
pass
class ConfigIniFile(ConfigFile):
def __init__(self):
self.parser = ConfigParser.ConfigParser()
def load(self, config_file):
self.parser.read(config_file)
def get_all_object_names(self):
return self.parser.sections()
def get_param(self, object_name, param_name):
return self.parser.get(object_name, param_name)
def get_param_vector(self, object_name, param_name):
return self.parser.get(object_name, param_name).split()
def get_object_children(self, object_name):
if self.parser.has_option(object_name, 'children'):
children = self.parser.get(object_name, 'children')
child_names = children.split()
else:
child_names = []
def make_path(child_name):
if object_name == 'root':
return child_name
else:
return '%s.%s' % (object_name, child_name)
return [ (name, make_path(name)) for name in child_names ]
def get_port_peers(self, object_name, port_name):
if self.parser.has_option(object_name, port_name):
peer_string = self.parser.get(object_name, port_name)
return peer_string.split()
else:
return []
class ConfigJsonFile(ConfigFile):
def __init__(self):
pass
def is_sim_object(self, node):
return isinstance(node, dict) and 'path' in node
def find_all_objects(self, node):
if self.is_sim_object(node):
self.object_dicts[node['path']] = node
if isinstance(node, list):
for elem in node:
self.find_all_objects(elem)
elif isinstance(node, dict):
for elem in node.itervalues():
self.find_all_objects(elem)
def load(self, config_file):
root = json.load(open(config_file, 'r'))
self.object_dicts = {}
self.find_all_objects(root)
def get_all_object_names(self):
return sorted(self.object_dicts.keys())
def parse_param_string(self, node):
if node is None:
return "Null"
elif self.is_sim_object(node):
return node['path']
else:
return str(node)
def get_param(self, object_name, param_name):
obj = self.object_dicts[object_name]
return self.parse_param_string(obj[param_name])
def get_param_vector(self, object_name, param_name):
obj = self.object_dicts[object_name]
return [ self.parse_param_string(p) for p in obj[param_name] ]
def get_object_children(self, object_name):
"""It is difficult to tell which elements are children in the
JSON file as there is no explicit 'children' node. Take any
element which is a full SimObject description or a list of
SimObject descriptions. This will not work with a mixed list of
references and descriptions but that's a scenario that isn't
possible (very likely?) with gem5's binding/naming rules"""
obj = self.object_dicts[object_name]
children = []
for name, node in obj.iteritems():
if self.is_sim_object(node):
children.append((name, node['path']))
elif isinstance(node, list) and node != [] and all([
self.is_sim_object(e) for e in node ]):
children.append((name, [ e['path'] for e in node ]))
return children
def get_port_peers(self, object_name, port_name):
"""Get the 'peer' element of any node with 'peer' and 'role'
elements"""
obj = self.object_dicts[object_name]
peers = []
if port_name in obj and 'peer' in obj[port_name] and \
'role' in obj[port_name]:
peers = to_list(obj[port_name]['peer'])
return peers
parser = argparse.ArgumentParser()
parser.add_argument('config_file', metavar='config-file.ini',
help='.ini configuration file to load and run')
args = parser.parse_args(sys.argv[1:])
if args.config_file.endswith('.ini'):
config = ConfigIniFile()
config.load(args.config_file)
else:
config = ConfigJsonFile()
config.load(args.config_file)
ticks.fixGlobalFrequency()
mgr = ConfigManager(config)
mgr.find_all_objects()
m5.instantiate()
exit_event = m5.simulate()
print 'Exiting @ tick %i because %s' % (
m5.curTick(), exit_event.getCause())
| bsd-3-clause |
anupcshan/bazel | tools/build_defs/docker/join_layers.py | 8 | 3624 | # Copyright 2015 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This tool creates a docker image from a list of layers."""
# This is the main program to create a docker image. It expect to be run with:
# join_layers --output=output_file \
# --layer=layer1 [--layer=layer2 ... --layer=layerN] \
# --id=@identifier \
# --name=myname --repository=repositoryName
# See the gflags declaration about the flags argument details.
import os.path
import sys
from tools.build_defs.pkg import archive
from third_party.py import gflags
gflags.DEFINE_string('output', None, 'The output file, mandatory')
gflags.MarkFlagAsRequired('output')
gflags.DEFINE_multistring('layer', [], 'The tar files for layers to join.')
gflags.DEFINE_string(
'id', None, 'The hex identifier of the top layer (hexstring or @filename).')
gflags.DEFINE_string(
'repository', None,
'The name of the repository to add this image (use with --id and --name).')
gflags.DEFINE_string(
'name', None,
'The symbolic name of this image (use with --id and --repsoitory).')
FLAGS = gflags.FLAGS
def _layer_filter(name):
"""Ignore files 'top' and 'repositories' when merging layers."""
basename = os.path.basename(name)
return basename not in ('top', 'repositories')
def create_image(output, layers, identifier=None,
name=None, repository=None):
"""Creates a Docker image from a list of layers.
Args:
output: the name of the docker image file to create.
layers: the layers (tar files) to join to the image.
identifier: the identifier of the top layer for this image.
name: symbolic name for this docker image.
repository: repository name for this docker image.
"""
tar = archive.TarFileWriter(output)
for layer in layers:
tar.add_tar(layer, name_filter=_layer_filter)
# In addition to N layers of the form described above, there might be
# a single file at the top of the image called repositories.
# This file contains a JSON blob of the form:
# {
# 'repo':{
# 'tag-name': 'top-most layer hex',
# ...
# },
# ...
# }
if identifier:
# If the identifier is not provided, then the resulted layer will be
# created without a 'top' file. Docker doesn't needs that file nor
# the repository to load the image and for intermediate layer,
# docker_build store the name of the layer in a separate artifact so
# this 'top' file is not needed.
tar.add_file('top', content=identifier)
if repository and name:
tar.add_file('repositories',
content='\n'.join([
'{', ' "%s": {' % repository, ' "%s": "%s"' % (
name, identifier), ' }', '}'
]))
def main(unused_argv):
identifier = FLAGS.id
if identifier and identifier.startswith('@'):
with open(identifier[1:], 'r') as f:
identifier = f.read()
create_image(FLAGS.output, FLAGS.layer, identifier, FLAGS.name,
FLAGS.repository)
if __name__ == '__main__':
main(FLAGS(sys.argv))
| apache-2.0 |
amboutin/GCP | speech/grpc/transcribe_streaming_minute.py | 2 | 10775 | #!/usr/bin/python
# Copyright (C) 2016 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Sample that streams audio to the Google Cloud Speech API via GRPC.
This sample expands on transcribe_streaming.py to work around the 1-minute
limit on streaming requests. It does this by transcribing normally until
WRAP_IT_UP_SECS seconds before the 1-minute limit. At that point, it waits for
the end of an utterance and once it hears it, it closes the current stream and
opens a new one. It also keeps a buffer of audio around while this is
happening, that it sends to the new stream in its initial request, to minimize
losing any speech that occurs while this happens.
Note that you could do this a little more simply by simply re-starting the
stream after every utterance, though this increases the possibility of audio
being missed between streams. For learning purposes (and robustness), the more
complex implementation is shown here.
"""
from __future__ import division
import argparse
import collections
import contextlib
import functools
import logging
import re
import signal
import sys
import time
import google.auth
import google.auth.transport.grpc
import google.auth.transport.requests
from google.cloud.proto.speech.v1beta1 import cloud_speech_pb2
from google.rpc import code_pb2
import grpc
import pyaudio
from six.moves import queue
# Seconds you have to wrap up your utterance
WRAP_IT_UP_SECS = 15
SECS_OVERLAP = 1
# Audio recording parameters
RATE = 16000
CHUNK = int(RATE / 10) # 100ms
# The Speech API has a streaming limit of 60 seconds of audio*, so keep the
# connection alive for that long, plus some more to give the API time to figure
# out the transcription.
# * https://g.co/cloud/speech/limits#content
DEADLINE_SECS = 60 * 3 + 5
SPEECH_SCOPE = 'https://www.googleapis.com/auth/cloud-platform'
def make_channel(host):
"""Creates a secure channel with auth credentials from the environment."""
# Grab application default credentials from the environment
credentials, _ = google.auth.default(scopes=[SPEECH_SCOPE])
# Create a secure channel using the credentials.
http_request = google.auth.transport.requests.Request()
return google.auth.transport.grpc.secure_authorized_channel(
credentials, http_request, host)
def _audio_data_generator(buff, overlap_buffer):
"""A generator that yields all available data in the given buffer.
Args:
buff (Queue): A Queue where each element is a chunk of data.
overlap_buffer (deque): a ring buffer for storing trailing data chunks
Yields:
bytes: A chunk of data that is the aggregate of all chunks of data in
`buff`. The function will block until at least one data chunk is
available.
"""
if overlap_buffer:
yield b''.join(overlap_buffer)
overlap_buffer.clear()
while True:
# Use a blocking get() to ensure there's at least one chunk of data.
data = [buff.get()]
# Now consume whatever other data's still buffered.
while True:
try:
data.append(buff.get(block=False))
except queue.Empty:
break
# `None` in the buffer signals that we should stop generating. Put the
# data back into the buffer for the next generator.
if None in data:
data.remove(None)
if data:
buff.put(b''.join(data))
break
else:
overlap_buffer.extend(data)
yield b''.join(data)
def _fill_buffer(buff, in_data, frame_count, time_info, status_flags):
"""Continuously collect data from the audio stream, into the buffer."""
buff.put(in_data)
return None, pyaudio.paContinue
# [START audio_stream]
@contextlib.contextmanager
def record_audio(rate, chunk):
"""Opens a recording stream in a context manager."""
# Create a thread-safe buffer of audio data
buff = queue.Queue()
audio_interface = pyaudio.PyAudio()
audio_stream = audio_interface.open(
format=pyaudio.paInt16,
# The API currently only supports 1-channel (mono) audio
# https://goo.gl/z757pE
channels=1, rate=rate,
input=True, frames_per_buffer=chunk,
# Run the audio stream asynchronously to fill the buffer object.
# This is necessary so that the input device's buffer doesn't overflow
# while the calling thread makes network requests, etc.
stream_callback=functools.partial(_fill_buffer, buff),
)
yield buff
audio_stream.stop_stream()
audio_stream.close()
# Signal the _audio_data_generator to finish
buff.put(None)
audio_interface.terminate()
# [END audio_stream]
def request_stream(data_stream, rate, interim_results=True):
"""Yields `StreamingRecognizeRequest`s constructed from a recording audio
stream.
Args:
data_stream (generator): The raw audio data to send.
rate (int): The sampling rate in hertz.
interim_results (boolean): Whether to return intermediate results,
before the transcription is finalized.
"""
# The initial request must contain metadata about the stream, so the
# server knows how to interpret it.
recognition_config = cloud_speech_pb2.RecognitionConfig(
# There are a bunch of config options you can specify. See
# https://goo.gl/KPZn97 for the full list.
encoding='LINEAR16', # raw 16-bit signed LE samples
sample_rate=rate, # the rate in hertz
# See http://g.co/cloud/speech/docs/languages
# for a list of supported languages.
language_code='en-US', # a BCP-47 language tag
)
streaming_config = cloud_speech_pb2.StreamingRecognitionConfig(
interim_results=interim_results,
config=recognition_config,
)
yield cloud_speech_pb2.StreamingRecognizeRequest(
streaming_config=streaming_config)
for data in data_stream:
# Subsequent requests can all just have the content
yield cloud_speech_pb2.StreamingRecognizeRequest(audio_content=data)
def listen_print_loop(
recognize_stream, wrap_it_up_secs, buff, max_recog_secs=60):
"""Iterates through server responses and prints them.
The recognize_stream passed is a generator that will block until a response
is provided by the server. When the transcription response comes, print it.
In this case, responses are provided for interim results as well. If the
response is an interim one, print a line feed at the end of it, to allow
the next result to overwrite it, until the response is a final one. For the
final one, print a newline to preserve the finalized transcription.
"""
# What time should we switch to a new stream?
time_to_switch = time.time() + max_recog_secs - wrap_it_up_secs
graceful_exit = False
num_chars_printed = 0
for resp in recognize_stream:
if resp.error.code != code_pb2.OK:
raise RuntimeError('Server error: ' + resp.error.message)
if not resp.results:
if resp.endpointer_type is resp.END_OF_SPEECH and (
time.time() > time_to_switch):
graceful_exit = True
buff.put(None)
continue
# Display the top transcription
result = resp.results[0]
transcript = result.alternatives[0].transcript
# If the previous result was longer than this one, we need to print
# some extra spaces to overwrite the previous result
overwrite_chars = ' ' * max(0, num_chars_printed - len(transcript))
# Display interim results, but with a carriage return at the end of the
# line, so subsequent lines will overwrite them.
if not result.is_final:
sys.stdout.write(transcript + overwrite_chars + '\r')
sys.stdout.flush()
num_chars_printed = len(transcript)
else:
print(transcript + overwrite_chars)
# Exit recognition if any of the transcribed phrases could be
# one of our keywords.
if re.search(r'\b(exit|quit)\b', transcript, re.I):
print('Exiting..')
recognize_stream.cancel()
elif graceful_exit:
break
num_chars_printed = 0
def main():
service = cloud_speech_pb2.SpeechStub(
make_channel('speech.googleapis.com'))
# For streaming audio from the microphone, there are three threads.
# First, a thread that collects audio data as it comes in
with record_audio(RATE, CHUNK) as buff:
# Second, a thread that sends requests with that data
overlap_buffer = collections.deque(
maxlen=int(SECS_OVERLAP * RATE / CHUNK))
requests = request_stream(
_audio_data_generator(buff, overlap_buffer), RATE)
# Third, a thread that listens for transcription responses
recognize_stream = service.StreamingRecognize(
requests, DEADLINE_SECS)
# Exit things cleanly on interrupt
signal.signal(signal.SIGINT, lambda *_: recognize_stream.cancel())
# Now, put the transcription responses to use.
try:
while True:
listen_print_loop(recognize_stream, WRAP_IT_UP_SECS, buff)
# Discard this stream and create a new one.
# Note: calling .cancel() doesn't immediately raise an RpcError
# - it only raises when the iterator's next() is requested
recognize_stream.cancel()
logging.debug('Starting new stream')
requests = request_stream(_audio_data_generator(
buff, overlap_buffer), RATE)
recognize_stream = service.StreamingRecognize(
requests, DEADLINE_SECS)
except grpc.RpcError:
# This happens because of the interrupt handler
pass
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'-v', '--verbose', help='increase output verbosity',
action='store_true')
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
main()
| apache-2.0 |
ujenmr/ansible | lib/ansible/modules/network/f5/bigip_gtm_monitor_bigip.py | 14 | 22153 | #!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright: (c) 2017, F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'certified'}
DOCUMENTATION = r'''
---
module: bigip_gtm_monitor_bigip
short_description: Manages F5 BIG-IP GTM BIG-IP monitors
description:
- Manages F5 BIG-IP GTM BIG-IP monitors. This monitor is used by GTM to monitor
BIG-IPs themselves.
version_added: 2.6
options:
name:
description:
- Monitor name.
required: True
parent:
description:
- The parent template of this monitor template. Once this value has
been set, it cannot be changed. By default, this value is the C(bigip)
parent on the C(Common) partition.
default: "/Common/bigip"
ip:
description:
- IP address part of the IP/port definition. If this parameter is not
provided when creating a new monitor, then the default value will be
'*'.
port:
description:
- Port address part of the IP/port definition. If this parameter is not
provided when creating a new monitor, then the default value will be
'*'. Note that if specifying an IP address, a value between 1 and 65535
must be specified
interval:
description:
- Specifies, in seconds, the frequency at which the system issues the monitor
check when either the resource is down or the status of the resource is unknown.
- When creating a new monitor, if this parameter is not provided, then the
default value will be C(30). This value B(must) be less than the C(timeout) value.
timeout:
description:
- Specifies the number of seconds the target has in which to respond to the
monitor request.
- If the target responds within the set time period, it is considered up.
- If the target does not respond within the set time period, it is considered down.
- When this value is set to 0 (zero), the system uses the interval from the parent monitor.
- When creating a new monitor, if this parameter is not provided, then
the default value will be C(90).
ignore_down_response:
description:
- Specifies that the monitor allows more than one probe attempt per interval.
- When C(yes), specifies that the monitor ignores down responses for the duration of
the monitor timeout. Once the monitor timeout is reached without the system receiving
an up response, the system marks the object down.
- When C(no), specifies that the monitor immediately marks an object down when it
receives a down response.
- When creating a new monitor, if this parameter is not provided, then the default
value will be C(no).
type: bool
aggregate_dynamic_ratios:
description:
- Specifies how the system combines the module values to create the proportion
(score) for the load balancing operation.
- The score represents the module's estimated capacity for handing traffic.
- Averaged values are appropriate for downstream Web Accelerator or Application
Security Manager virtual servers.
- When creating a new monitor, if this parameter is not specified, the default
of C(none) is used, meaning that the system does not use the scores in the load
balancing operation.
- When C(none), specifies that the monitor ignores the nodes and pool member scores.
- When C(average-nodes), specifies that the system averages the dynamic ratios
on the nodes associated with the monitor's target virtual servers and returns
that average as the virtual servers' score.
- When C(sum-nodes), specifies that the system adds together the scores of the
nodes associated with the monitor's target virtual servers and uses that value
in the load balancing operation.
- When C(average-members), specifies that the system averages the dynamic ratios
on the pool members associated with the monitor's target virtual servers and
returns that average as the virtual servers' score.
- When C(sum-members), specifies that the system adds together the scores of the
pool members associated with the monitor's target virtual servers and uses
that value in the load balancing operation.
choices:
- none
- average-nodes
- sum-nodes
- average-members
- sum-members
partition:
description:
- Device partition to manage resources on.
default: Common
state:
description:
- When C(present), ensures that the monitor exists.
- When C(absent), ensures the monitor is removed.
default: present
choices:
- present
- absent
notes:
- Requires BIG-IP software version >= 12
extends_documentation_fragment: f5
author:
- Tim Rupp (@caphrim007)
- Wojciech Wypior (@wojtek0806)
'''
EXAMPLES = r'''
- name: Create BIG-IP Monitor
bigip_gtm_monitor_bigip:
state: present
ip: 10.10.10.10
name: my_monitor
provider:
user: admin
password: secret
server: lb.mydomain.com
delegate_to: localhost
- name: Remove BIG-IP Monitor
bigip_gtm_monitor_bigip:
state: absent
name: my_monitor
provider:
user: admin
password: secret
server: lb.mydomain.com
delegate_to: localhost
- name: Add BIG-IP monitor for all addresses, port 514
bigip_gtm_monitor_bigip:
port: 514
name: my_monitor
provider:
user: admin
password: secret
server: lb.mydomain.com
delegate_to: localhost
'''
RETURN = r'''
parent:
description: New parent template of the monitor.
returned: changed
type: str
sample: bigip
ip:
description: The new IP of IP/port definition.
returned: changed
type: str
sample: 10.12.13.14
interval:
description: The new interval in which to run the monitor check.
returned: changed
type: int
sample: 2
timeout:
description: The new timeout in which the remote system must respond to the monitor.
returned: changed
type: int
sample: 10
aggregate_dynamic_ratios:
description: The new aggregate of to the monitor.
returned: changed
type: str
sample: sum-members
ignore_down_response:
description: Whether to ignore the down response or not.
returned: changed
type: bool
sample: True
'''
import os
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.basic import env_fallback
try:
from library.module_utils.network.f5.bigip import F5RestClient
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import AnsibleF5Parameters
from library.module_utils.network.f5.common import cleanup_tokens
from library.module_utils.network.f5.common import fq_name
from library.module_utils.network.f5.common import f5_argument_spec
from library.module_utils.network.f5.common import transform_name
from library.module_utils.network.f5.common import exit_json
from library.module_utils.network.f5.common import fail_json
from library.module_utils.network.f5.icontrol import module_provisioned
from library.module_utils.network.f5.ipaddress import is_valid_ip
except ImportError:
from ansible.module_utils.network.f5.bigip import F5RestClient
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import AnsibleF5Parameters
from ansible.module_utils.network.f5.common import cleanup_tokens
from ansible.module_utils.network.f5.common import fq_name
from ansible.module_utils.network.f5.common import f5_argument_spec
from ansible.module_utils.network.f5.common import transform_name
from ansible.module_utils.network.f5.common import exit_json
from ansible.module_utils.network.f5.common import fail_json
from ansible.module_utils.network.f5.icontrol import module_provisioned
from ansible.module_utils.network.f5.ipaddress import is_valid_ip
class Parameters(AnsibleF5Parameters):
api_map = {
'defaultsFrom': 'parent',
'ignoreDownResponse': 'ignore_down_response',
'aggregateDynamicRatios': 'aggregate_dynamic_ratios',
}
api_attributes = [
'defaultsFrom', 'interval', 'timeout', 'destination', 'ignoreDownResponse',
'aggregateDynamicRatios',
]
returnables = [
'parent', 'ip', 'port', 'interval', 'timeout', 'ignore_down_response',
'aggregate_dynamic_ratios',
]
updatables = [
'destination', 'interval', 'timeout', 'ignore_down_response',
'aggregate_dynamic_ratios',
]
@property
def interval(self):
if self._values['interval'] is None:
return None
if 1 > int(self._values['interval']) > 86400:
raise F5ModuleError(
"Interval value must be between 1 and 86400"
)
return int(self._values['interval'])
@property
def timeout(self):
if self._values['timeout'] is None:
return None
return int(self._values['timeout'])
@property
def type(self):
return 'bigip'
class ApiParameters(Parameters):
@property
def ip(self):
ip, port = self._values['destination'].split(':')
return ip
@property
def port(self):
ip, port = self._values['destination'].split(':')
return int(port)
@property
def ignore_down_response(self):
if self._values['ignore_down_response'] is None:
return None
if self._values['ignore_down_response'] == 'disabled':
return False
return True
class ModuleParameters(Parameters):
@property
def destination(self):
if self.ip is None and self.port is None:
return None
destination = '{0}:{1}'.format(self.ip, self.port)
return destination
@property
def parent(self):
if self._values['parent'] is None:
return None
if self._values['parent'].startswith('/'):
parent = os.path.basename(self._values['parent'])
result = '/{0}/{1}'.format(self.partition, parent)
else:
result = '/{0}/{1}'.format(self.partition, self._values['parent'])
return result
@property
def ip(self): # lgtm [py/similar-function]
if self._values['ip'] is None:
return None
if self._values['ip'] in ['*', '0.0.0.0']:
return '*'
elif is_valid_ip(self._values['ip']):
return self._values['ip']
else:
raise F5ModuleError(
"The provided 'ip' parameter is not an IP address."
)
@property
def port(self):
if self._values['port'] is None:
return None
elif self._values['port'] == '*':
return '*'
return int(self._values['port'])
class Changes(Parameters):
def to_return(self):
result = {}
try:
for returnable in self.returnables:
result[returnable] = getattr(self, returnable)
result = self._filter_params(result)
return result
except Exception:
return result
class UsableChanges(Changes):
@property
def ignore_down_response(self):
if self._values['ignore_down_response']:
return 'enabled'
return 'disabled'
class ReportableChanges(Changes):
pass
class Difference(object):
def __init__(self, want, have=None):
self.want = want
self.have = have
def compare(self, param):
try:
result = getattr(self, param)
return result
except AttributeError:
result = self.__default(param)
return result
@property
def parent(self):
if self.want.parent != self.have.parent:
raise F5ModuleError(
"The parent monitor cannot be changed"
)
@property
def destination(self):
if self.want.ip is None and self.want.port is None:
return None
if self.want.port is None:
self.want.update({'port': self.have.port})
if self.want.ip is None:
self.want.update({'ip': self.have.ip})
if self.want.port in [None, '*'] and self.want.ip != '*':
raise F5ModuleError(
"Specifying an IP address requires that a port number be specified"
)
if self.want.destination != self.have.destination:
return self.want.destination
@property
def interval(self):
if self.want.timeout is not None and self.want.interval is not None:
if self.want.interval >= self.want.timeout:
raise F5ModuleError(
"Parameter 'interval' must be less than 'timeout'."
)
elif self.want.timeout is not None:
if self.have.interval >= self.want.timeout:
raise F5ModuleError(
"Parameter 'interval' must be less than 'timeout'."
)
elif self.want.interval is not None:
if self.want.interval >= self.have.timeout:
raise F5ModuleError(
"Parameter 'interval' must be less than 'timeout'."
)
if self.want.interval != self.have.interval:
return self.want.interval
def __default(self, param):
attr1 = getattr(self.want, param)
try:
attr2 = getattr(self.have, param)
if attr1 != attr2:
return attr1
except AttributeError:
return attr1
class ModuleManager(object):
def __init__(self, *args, **kwargs):
self.module = kwargs.get('module', None)
self.client = kwargs.get('client', None)
self.have = None
self.want = ModuleParameters(params=self.module.params)
self.changes = UsableChanges()
def _set_changed_options(self):
changed = {}
for key in Parameters.returnables:
if getattr(self.want, key) is not None:
changed[key] = getattr(self.want, key)
if changed:
self.changes = UsableChanges(params=changed)
def _update_changed_options(self): # lgtm [py/similar-function]
diff = Difference(self.want, self.have)
updatables = Parameters.updatables
changed = dict()
for k in updatables:
change = diff.compare(k)
if change is None:
continue
else:
changed[k] = change
if changed:
self.changes = UsableChanges(params=changed)
return True
return False
def _announce_deprecations(self, result):
warnings = result.pop('__warnings', [])
for warning in warnings:
self.module.deprecate(
msg=warning['msg'],
version=warning['version']
)
def _set_default_creation_values(self):
if self.want.timeout is None:
self.want.update({'timeout': 120})
if self.want.interval is None:
self.want.update({'interval': 30})
if self.want.ip is None:
self.want.update({'ip': '*'})
if self.want.port is None:
self.want.update({'port': '*'})
if self.want.ignore_down_response is None:
self.want.update({'ignore_down_response': False})
if self.want.aggregate_dynamic_ratios is None:
self.want.update({'aggregate_dynamic_ratios': 'none'})
def exec_module(self):
if not module_provisioned(self.client, 'gtm'):
raise F5ModuleError(
"GTM must be provisioned to use this module."
)
changed = False
result = dict()
state = self.want.state
if state in ["present", "disabled"]:
changed = self.present()
elif state == "absent":
changed = self.absent()
reportable = ReportableChanges(params=self.changes.to_return())
changes = reportable.to_return()
result.update(**changes)
result.update(dict(changed=changed))
self._announce_deprecations(result)
return result
def present(self):
if self.exists():
return self.update()
else:
return self.create()
def create(self):
self._set_changed_options()
self._set_default_creation_values()
if self.module.check_mode:
return True
self.create_on_device()
return True
def should_update(self):
result = self._update_changed_options()
if result:
return True
return False
def update(self):
self.have = self.read_current_from_device()
if not self.should_update():
return False
if self.module.check_mode:
return True
self.update_on_device()
return True
def absent(self):
if self.exists():
return self.remove()
return False
def remove(self):
if self.module.check_mode:
return True
self.remove_from_device()
if self.exists():
raise F5ModuleError("Failed to delete the monitor.")
return True
def exists(self):
uri = "https://{0}:{1}/mgmt/tm/gtm/monitor/bigip/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError:
return False
if resp.status == 404 or 'code' in response and response['code'] == 404:
return False
return True
def create_on_device(self):
params = self.changes.api_params()
params['name'] = self.want.name
params['partition'] = self.want.partition
uri = "https://{0}:{1}/mgmt/tm/gtm/monitor/bigip/".format(
self.client.provider['server'],
self.client.provider['server_port']
)
resp = self.client.api.post(uri, json=params)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] in [400, 403]:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
def update_on_device(self):
params = self.changes.api_params()
uri = "https://{0}:{1}/mgmt/tm/gtm/monitor/bigip/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.patch(uri, json=params)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
def remove_from_device(self):
uri = "https://{0}:{1}/mgmt/tm/gtm/monitor/bigip/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.delete(uri)
if resp.status == 200:
return True
def read_current_from_device(self):
uri = "https://{0}:{1}/mgmt/tm/gtm/monitor/bigip/{2}".format(
self.client.provider['server'],
self.client.provider['server_port'],
transform_name(self.want.partition, self.want.name)
)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
return ApiParameters(params=response)
class ArgumentSpec(object):
def __init__(self):
self.supports_check_mode = True
argument_spec = dict(
name=dict(required=True),
parent=dict(default='/Common/bigip'),
ip=dict(),
port=dict(),
interval=dict(type='int'),
timeout=dict(type='int'),
ignore_down_response=dict(type='bool'),
aggregate_dynamic_ratios=dict(
choices=[
'none', 'average-nodes', 'sum-nodes', 'average-members', 'sum-members'
]
),
state=dict(
default='present',
choices=['present', 'absent']
),
partition=dict(
default='Common',
fallback=(env_fallback, ['F5_PARTITION'])
)
)
self.argument_spec = {}
self.argument_spec.update(f5_argument_spec)
self.argument_spec.update(argument_spec)
def main():
spec = ArgumentSpec()
module = AnsibleModule(
argument_spec=spec.argument_spec,
supports_check_mode=spec.supports_check_mode,
)
client = F5RestClient(**module.params)
try:
mm = ModuleManager(module=module, client=client)
results = mm.exec_module()
cleanup_tokens(client)
exit_json(module, results, client)
except F5ModuleError as ex:
cleanup_tokens(client)
fail_json(module, ex, client)
if __name__ == '__main__':
main()
| gpl-3.0 |
renhaocui/adPlatform | caseStudy.py | 2 | 26683 | __author__ = 'rencui'
from afinn import Afinn
from sklearn.externals import joblib
import numpy
import json
from textstat.textstat import textstat
from nltk.stem.porter import *
from tokenizer import simpleTokenize
import logging
from scipy.sparse import hstack, csr_matrix
from sklearn import svm
stemmer = PorterStemmer()
logging.basicConfig()
def mapMention(inputFile):
mentionFile = open(inputFile, 'r')
outputMapper = {}
for line in mentionFile:
mention = json.loads(line.strip())
if mention['verified'] == 'true':
verify = 1
else:
verify = 0
outputMapper[mention['screen_name']] = (verify, mention['followers_count'])
mentionFile.close()
return outputMapper
def stemContent(input):
words = simpleTokenize(input)
out = ''
for word in words:
temp = stemmer.stem(word)
out += temp + ' '
return out.strip()
def POSRatio(inputList):
out = []
temp = []
for item in inputList:
temp.append(float(item))
if sum(temp) == 0:
out = [0.0, 0.0, 0.0]
else:
for item in temp:
out.append(item / sum(temp))
return out
def longestLength(input):
outputLength = 0
for key, value in input.items():
length = 0
if value != '-1' and value != '_':
length += 1
if value == '0':
if length > outputLength:
outputLength = length
continue
nextNode = value
while nextNode != '-1' and nextNode != '_' and nextNode != '0':
length += 1
nextNode = input[nextNode]
if length > outputLength:
outputLength = length
return outputLength
def POSRatio(inputList):
out = []
temp = []
for item in inputList:
temp.append(float(item))
if sum(temp) == 0:
out = [0.0, 0.0, 0.0]
else:
for item in temp:
out.append(item / sum(temp))
return out
def outputHeads(input):
output = ''
for key, value in input.items():
if value[1] == 0:
output += value[0] + '/' + value[2] + ' '
return output.strip()
def run(group, groupTitle, outputFile='result.output'):
resultFile = open(outputFile, 'a')
mentionMapper = mapMention('adData/analysis/ranked/mention.json')
print groupTitle
resultFile.write(groupTitle + '\n')
print 'group: ' + str(group)
resultFile.write('group: ' + str(group) + '\n')
afinn = Afinn()
posFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.pos', 'r')
negFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.neg', 'r')
posParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.pos', 'r')
negParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.neg', 'r')
posHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.pos', 'r')
negHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.neg', 'r')
posPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.pos', 'r')
negPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.neg', 'r')
ids = []
contents = []
scores = []
labels = []
parseLength = []
headCount = []
usernames = []
POScounts = []
print 'loading...'
for line in posFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(1)
for line in negFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(0)
for line in posParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in negParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in posHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in negHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in posPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
for line in negPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
posHeadCountFile.close()
negHeadCountFile.close()
posParseLengthFile.close()
negParseLengthFile.close()
posPOSCountFile.close()
negPOSCountFile.close()
posFile.close()
negFile.close()
semanticFeatures_train = []
semanticFeatures_test = []
classes_train = []
classes_test = []
index_test = []
for index, content in enumerate(contents):
temp = []
words = simpleTokenize(content)
twLen = float(len(words))
sentiScore = afinn.score(stemContent(content))
readScore = textstat.coleman_liau_index(content)
temp.append(twLen)
if content.count('URRL') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('HHTTG') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('USSERNM') > 0:
temp.append(1)
else:
temp.append(0)
temp.append(sentiScore / twLen)
temp.append(readScore)
temp.append(parseLength[index] / twLen)
temp.append(headCount[index] / twLen)
temp += POScounts[index]
if content.count('!') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('?') > 0:
temp.append(1)
else:
temp.append(0)
mentionFlag = 0
mentionFollowers = 0
userCount = 0.0
for user in usernames[index]:
if user in mentionMapper:
userCount += 1
if mentionMapper[user][0] == 1:
mentionFlag = 1
mentionFollowers += mentionMapper[user][1]
temp.append(mentionFlag)
if userCount == 0:
temp.append(0.0)
else:
temp.append(mentionFollowers / userCount)
if index % 5 == 0:
semanticFeatures_test.append(numpy.array(temp))
classes_test.append(labels[index])
index_test.append(index)
else:
semanticFeatures_train.append(numpy.array(temp))
classes_train.append(labels[index])
feature_train = csr_matrix(numpy.array(semanticFeatures_train))
feature_test = csr_matrix(numpy.array(semanticFeatures_test))
resultFile.flush()
model = svm.SVC()
model.fit(feature_train, classes_train)
predictions = model.predict(feature_test)
if len(predictions) != len(classes_test):
print 'inference error!'
for index, label in enumerate(predictions):
if label == 0 and classes_test[index] == 1:
print ids[index_test[index]]
print contents[index_test[index]]
resultFile.flush()
resultFile.write('\n')
resultFile.flush()
resultFile.close()
def run2(group, groupTitle, outputFile='result.output'):
resultFile = open(outputFile, 'a')
mentionMapper = mapMention('adData/analysis/ranked/mention.json')
tempListFile = open('results/temp.list', 'r')
excludeList = []
for line in tempListFile:
excludeList.append(line.strip())
print groupTitle
resultFile.write(groupTitle + '\n')
print 'group: ' + str(group)
resultFile.write('group: ' + str(group) + '\n')
afinn = Afinn()
posFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.pos', 'r')
negFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.neg', 'r')
posParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.pos', 'r')
negParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.neg', 'r')
posHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.pos', 'r')
negHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.neg', 'r')
posPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.pos', 'r')
negPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.neg', 'r')
ids = []
contents = []
scores = []
labels = []
parseLength = []
headCount = []
usernames = []
POScounts = []
print 'loading...'
for line in posFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(1)
for line in negFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(0)
for line in posParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in negParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in posHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in negHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in posPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
for line in negPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
posHeadCountFile.close()
negHeadCountFile.close()
posParseLengthFile.close()
negParseLengthFile.close()
posPOSCountFile.close()
negPOSCountFile.close()
posFile.close()
negFile.close()
semanticFeatures_train = []
semanticFeatures_test = []
classes_train = []
classes_test = []
index_test = []
for index, content in enumerate(contents):
temp = []
words = simpleTokenize(content)
twLen = float(len(words))
sentiScore = afinn.score(stemContent(content))
readScore = textstat.coleman_liau_index(content)
temp.append(twLen)
if content.count('URRL') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('HHTTG') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('USSERNM') > 0:
temp.append(1)
else:
temp.append(0)
temp.append(sentiScore / twLen)
temp.append(readScore)
temp.append(parseLength[index] / twLen)
temp.append(headCount[index] / twLen)
temp += POScounts[index]
if content.count('!') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('?') > 0:
temp.append(1)
else:
temp.append(0)
mentionFlag = 0
mentionFollowers = 0
userCount = 0.0
for user in usernames[index]:
if user in mentionMapper:
userCount += 1
if mentionMapper[user][0] == 1:
mentionFlag = 1
mentionFollowers += mentionMapper[user][1]
temp.append(mentionFlag)
if userCount == 0:
temp.append(0.0)
else:
temp.append(mentionFollowers / userCount)
if index % 5 == 0:
semanticFeatures_test.append(numpy.array(temp))
classes_test.append(labels[index])
index_test.append(index)
else:
semanticFeatures_train.append(numpy.array(temp))
classes_train.append(labels[index])
feature_train = csr_matrix(numpy.array(semanticFeatures_train))
feature_test = csr_matrix(numpy.array(semanticFeatures_test))
resultFile.flush()
model = svm.SVC()
model.fit(feature_train, classes_train)
# joblib.dump(model, 'results/full.pkl')
# model = joblib.load('results/full.pkl')
predictions = model.predict(feature_test)
if len(predictions) != len(classes_test):
print 'inference error!'
for index, label in enumerate(predictions):
# tempListFile.write(ids[index_test[index]]+'\n')
if label == 1 and classes_test[index] == 1:
print ids[index_test[index]]
print contents[index_test[index]]
resultFile.flush()
resultFile.write('\n')
resultFile.flush()
tempListFile.close()
resultFile.close()
def run3():
mentionMapper = mapMention('adData/analysis/ranked/mention.json')
tempListFile = open('results/temp.list', 'r')
excludeList = []
for line in tempListFile:
excludeList.append(line.strip())
groupTitle = 'totalGroup'
group = 0
afinn = Afinn()
posFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.pos', 'r')
negFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.neg', 'r')
posParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.pos', 'r')
negParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.neg', 'r')
posHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.pos', 'r')
negHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.neg', 'r')
posPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.pos', 'r')
negPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.neg', 'r')
ids = []
contents = []
scores = []
labels = []
parseLength = []
headCount = []
usernames = []
POScounts = []
print 'loading...'
for line in posFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(1)
for line in negFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(0)
for line in posParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in negParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in posHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in negHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in posPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
for line in negPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
posHeadCountFile.close()
negHeadCountFile.close()
posParseLengthFile.close()
negParseLengthFile.close()
posPOSCountFile.close()
negPOSCountFile.close()
posFile.close()
negFile.close()
semanticFeatures_train = []
semanticFeatures_test = []
classes_train = []
classes_test = []
index_test = []
for index, content in enumerate(contents):
temp = []
words = simpleTokenize(content)
twLen = float(len(words))
sentiScore = afinn.score(stemContent(content))
readScore = textstat.coleman_liau_index(content)
temp.append(twLen)
if content.count('URRL') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('HHTTG') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('USSERNM') > 0:
temp.append(1)
else:
temp.append(0)
temp.append(sentiScore / twLen)
temp.append(readScore)
temp.append(parseLength[index] / twLen)
temp.append(headCount[index] / twLen)
temp += POScounts[index]
if content.count('!') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('?') > 0:
temp.append(1)
else:
temp.append(0)
mentionFlag = 0
mentionFollowers = 0
userCount = 0.0
for user in usernames[index]:
if user in mentionMapper:
userCount += 1
if mentionMapper[user][0] == 1:
mentionFlag = 1
mentionFollowers += mentionMapper[user][1]
temp.append(mentionFlag)
if userCount == 0:
temp.append(0.0)
else:
temp.append(mentionFollowers / userCount)
if ids[index] not in excludeList:
semanticFeatures_train.append(numpy.array(temp))
classes_train.append(labels[index])
else:
semanticFeatures_test.append(numpy.array(temp))
classes_test.append(labels[index])
print ids[index] + '\t' + contents[index] + '\t' + str(usernames[index])
feature_train = csr_matrix(numpy.array(semanticFeatures_train))
feature_test = csr_matrix(numpy.array(semanticFeatures_test))
model = svm.SVC()
model.fit(feature_train, classes_train)
# joblib.dump(model, 'results/full.pkl')
# model = joblib.load('results/full.pkl')
predictions = model.predict(feature_test)
score = model.decision_function(feature_test)
print classes_test
print predictions
print score
tempListFile.close()
def trainModel(groupTitle):
print 'loading...'
mentionMapper = mapMention('adData/analysis/ranked/mention.json')
group = 0
afinn = Afinn()
posFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.pos', 'r')
negFile = open('adData/analysis/groups/' + groupTitle + '/group' + str(group) + '.neg', 'r')
posParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.pos', 'r')
negParseLengthFile = open('adData/analysis/groups/' + groupTitle + '/parserLength' + str(group) + '.neg', 'r')
posHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.pos', 'r')
negHeadCountFile = open('adData/analysis/groups/' + groupTitle + '/parserHeadCount' + str(group) + '.neg', 'r')
posPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.pos', 'r')
negPOSCountFile = open('adData/analysis/groups/' + groupTitle + '/parserPOSCount' + str(group) + '.neg', 'r')
ids = []
contents = []
scores = []
labels = []
parseLength = []
headCount = []
usernames = []
POScounts = []
for line in posFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(1)
for line in negFile:
seg = line.strip().split(' :: ')
text = seg[3]
username = seg[7].split(';')
score = float(seg[0])
ids.append(seg[5])
usernames.append(username)
contents.append(text)
scores.append(score)
labels.append(0)
for line in posParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in negParseLengthFile:
parseLength.append(int(line.strip(' :: ')[0]))
for line in posHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in negHeadCountFile:
headCount.append(int(line.strip(' :: ')[0]))
for line in posPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
for line in negPOSCountFile:
POScounts.append(POSRatio(line.strip().split(' :: ')[0].split(' ')))
posHeadCountFile.close()
negHeadCountFile.close()
posParseLengthFile.close()
negParseLengthFile.close()
posPOSCountFile.close()
negPOSCountFile.close()
posFile.close()
negFile.close()
semanticFeatures_train = []
classes_train = []
for index, content in enumerate(contents):
temp = []
words = simpleTokenize(content)
twLen = float(len(words))
sentiScore = afinn.score(stemContent(content))
readScore = textstat.coleman_liau_index(content)
temp.append(twLen)
if content.count('URRL') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('HHTTG') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('USSERNM') > 0:
temp.append(1)
else:
temp.append(0)
temp.append(sentiScore / twLen)
temp.append(readScore)
temp.append(parseLength[index] / twLen)
temp.append(headCount[index] / twLen)
temp += POScounts[index]
if content.count('!') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('?') > 0:
temp.append(1)
else:
temp.append(0)
mentionFlag = 0
mentionFollowers = 0
userCount = 0.0
for user in usernames[index]:
if user in mentionMapper:
userCount += 1
if mentionMapper[user][0] == 1:
mentionFlag = 1
mentionFollowers += mentionMapper[user][1]
temp.append(mentionFlag)
if userCount == 0:
temp.append(0.0)
else:
temp.append(mentionFollowers / userCount)
semanticFeatures_train.append(numpy.array(temp))
classes_train.append(labels[index])
feature_train = csr_matrix(numpy.array(semanticFeatures_train))
model = svm.SVC()
model.fit(feature_train, classes_train)
joblib.dump(model, 'models/full.pkl')
def extractor():
inputFile = open('infer/test.predict', 'r')
tempData = {}
tempOutput = {}
posCount = {'N': 0, 'V': 0, 'A': 0}
lengthOutput = []
headOutput = []
posOutput = []
for line in inputFile:
if line.strip() != '':
words = line.strip().split()
tempData[words[0]] = words[6]
tempOutput[int(words[0])] = (words[1], int(words[6]), words[4])
if words[4] in ['N', '^']:
posCount['N'] += 1
elif words[4] == 'V':
posCount['V'] += 1
elif words[4] in ['A', 'R']:
posCount['A'] += 1
else:
longLen = longestLength(tempData)
lengthOutput.append(longLen)
headOutput.append(len(outputHeads(tempOutput).split()))
posOutput.append((posCount['N'], posCount['V'], posCount['A']))
tempData = {}
tempOutput = {}
posCount = {'N': 0, 'V': 0, 'A': 0}
inputFile.close()
return lengthOutput, headOutput, posOutput
def infer():
print 'loading...'
mentionMapper = mapMention('adData/analysis/ranked/mention.json')
afinn = Afinn()
mentionFile = open('infer/mention.input', 'r')
inputFile = open('infer/test', 'r')
contents = []
usernames = []
for line in inputFile:
text = line.strip()
contents.append(text)
for i in range(len(contents)):
usernames.append([])
for line in mentionFile:
items = line.strip().split(';')
if len(items) == 0:
usernames.append([])
else:
usernames.append(items)
parseLength, headCount, POSoutput = extractor()
inputFile.close()
mentionFile.close()
semanticFeatures_test = []
for index, content in enumerate(contents):
temp = []
words = simpleTokenize(content)
twLen = float(len(words))
sentiScore = afinn.score(stemContent(content))
readScore = textstat.coleman_liau_index(content)
temp.append(twLen)
if content.count('URRL') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('HHTTG') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('USSERNM') > 0:
temp.append(1)
else:
temp.append(0)
temp.append(sentiScore / twLen)
temp.append(readScore)
temp.append(parseLength[index] / twLen)
temp.append(headCount[index] / twLen)
temp += POSRatio(POSoutput[index])
if content.count('!') > 0:
temp.append(1)
else:
temp.append(0)
if content.count('?') > 0:
temp.append(1)
else:
temp.append(0)
mentionFlag = 0
mentionFollowers = 0
userCount = 0.0
for user in usernames[index]:
if user in mentionMapper:
userCount += 1
if mentionMapper[user][0] == 1:
mentionFlag = 1
mentionFollowers += mentionMapper[user][1]
temp.append(mentionFlag)
if userCount == 0:
temp.append(0.0)
else:
temp.append(mentionFollowers / userCount)
semanticFeatures_test.append(numpy.array(temp))
feature_test = csr_matrix(numpy.array(semanticFeatures_test))
model = joblib.load('models/full.pkl')
predictions = model.predict(feature_test)
score = model.decision_function(feature_test)
#print classes_test
#print predictions
#print numpy.count_nonzero(predictions)
for index, pred in enumerate(predictions):
#print pred
print score[index]
#print score
infer()
# trainModel('totalGroup')
# run3()
# outputFilename = 'results/test.result'
# run2(3, 'simGroup', outputFile=outputFilename)
| mit |
fkazimierczak/werkzeug | werkzeug/debug/console.py | 256 | 5599 | # -*- coding: utf-8 -*-
"""
werkzeug.debug.console
~~~~~~~~~~~~~~~~~~~~~~
Interactive console support.
:copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
:license: BSD.
"""
import sys
import code
from types import CodeType
from werkzeug.utils import escape
from werkzeug.local import Local
from werkzeug.debug.repr import debug_repr, dump, helper
_local = Local()
class HTMLStringO(object):
"""A StringO version that HTML escapes on write."""
def __init__(self):
self._buffer = []
def isatty(self):
return False
def close(self):
pass
def flush(self):
pass
def seek(self, n, mode=0):
pass
def readline(self):
if len(self._buffer) == 0:
return ''
ret = self._buffer[0]
del self._buffer[0]
return ret
def reset(self):
val = ''.join(self._buffer)
del self._buffer[:]
return val
def _write(self, x):
if isinstance(x, bytes):
x = x.decode('utf-8', 'replace')
self._buffer.append(x)
def write(self, x):
self._write(escape(x))
def writelines(self, x):
self._write(escape(''.join(x)))
class ThreadedStream(object):
"""Thread-local wrapper for sys.stdout for the interactive console."""
def push():
if not isinstance(sys.stdout, ThreadedStream):
sys.stdout = ThreadedStream()
_local.stream = HTMLStringO()
push = staticmethod(push)
def fetch():
try:
stream = _local.stream
except AttributeError:
return ''
return stream.reset()
fetch = staticmethod(fetch)
def displayhook(obj):
try:
stream = _local.stream
except AttributeError:
return _displayhook(obj)
# stream._write bypasses escaping as debug_repr is
# already generating HTML for us.
if obj is not None:
_local._current_ipy.locals['_'] = obj
stream._write(debug_repr(obj))
displayhook = staticmethod(displayhook)
def __setattr__(self, name, value):
raise AttributeError('read only attribute %s' % name)
def __dir__(self):
return dir(sys.__stdout__)
def __getattribute__(self, name):
if name == '__members__':
return dir(sys.__stdout__)
try:
stream = _local.stream
except AttributeError:
stream = sys.__stdout__
return getattr(stream, name)
def __repr__(self):
return repr(sys.__stdout__)
# add the threaded stream as display hook
_displayhook = sys.displayhook
sys.displayhook = ThreadedStream.displayhook
class _ConsoleLoader(object):
def __init__(self):
self._storage = {}
def register(self, code, source):
self._storage[id(code)] = source
# register code objects of wrapped functions too.
for var in code.co_consts:
if isinstance(var, CodeType):
self._storage[id(var)] = source
def get_source_by_code(self, code):
try:
return self._storage[id(code)]
except KeyError:
pass
def _wrap_compiler(console):
compile = console.compile
def func(source, filename, symbol):
code = compile(source, filename, symbol)
console.loader.register(code, source)
return code
console.compile = func
class _InteractiveConsole(code.InteractiveInterpreter):
def __init__(self, globals, locals):
code.InteractiveInterpreter.__init__(self, locals)
self.globals = dict(globals)
self.globals['dump'] = dump
self.globals['help'] = helper
self.globals['__loader__'] = self.loader = _ConsoleLoader()
self.more = False
self.buffer = []
_wrap_compiler(self)
def runsource(self, source):
source = source.rstrip() + '\n'
ThreadedStream.push()
prompt = self.more and '... ' or '>>> '
try:
source_to_eval = ''.join(self.buffer + [source])
if code.InteractiveInterpreter.runsource(self,
source_to_eval, '<debugger>', 'single'):
self.more = True
self.buffer.append(source)
else:
self.more = False
del self.buffer[:]
finally:
output = ThreadedStream.fetch()
return prompt + source + output
def runcode(self, code):
try:
eval(code, self.globals, self.locals)
except Exception:
self.showtraceback()
def showtraceback(self):
from werkzeug.debug.tbtools import get_current_traceback
tb = get_current_traceback(skip=1)
sys.stdout._write(tb.render_summary())
def showsyntaxerror(self, filename=None):
from werkzeug.debug.tbtools import get_current_traceback
tb = get_current_traceback(skip=4)
sys.stdout._write(tb.render_summary())
def write(self, data):
sys.stdout.write(data)
class Console(object):
"""An interactive console."""
def __init__(self, globals=None, locals=None):
if locals is None:
locals = {}
if globals is None:
globals = {}
self._ipy = _InteractiveConsole(globals, locals)
def eval(self, code):
_local._current_ipy = self._ipy
old_sys_stdout = sys.stdout
try:
return self._ipy.runsource(code)
finally:
sys.stdout = old_sys_stdout
| bsd-3-clause |
guerrierk/dolibarr | htdocs/modulebuilder/template/doc/user/source/conf.py | 19 | 12067 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# My Module documentation build configuration file, created by
# sphinx-quickstart on Mon Sep 26 17:54:17 2016.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.todo',
'sphinx.ext.imgmath',
'sphinx.ext.githubpages',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'My Module'
copyright = '2016, Raphaël Doursenaud <rdoursenaud@gpcsolutions.fr>'
author = 'Raphaël Doursenaud <rdoursenaud@gpcsolutions.fr>'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = 'development'
# The full version, including alpha/beta/rc tags.
release = 'development'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#
# today = ''
#
# Else, today_fmt is used as the format for a strftime call.
#
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = []
# The reST default role (used for this markup: `text`) to use for all
# documents.
#
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
# The name for this set of Sphinx documents.
# "<project> v<release> documentation" by default.
#
# html_title = 'My Module vdevelopment'
# A shorter title for the navigation bar. Default is the same as html_title.
#
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#
# html_logo = None
# The name of an image file (relative to this directory) to use as a favicon of
# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#
# html_extra_path = []
# If not None, a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
# The empty string is equivalent to '%b %d, %Y'.
#
# html_last_updated_fmt = None
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#
# html_additional_pages = {}
# If false, no module index is generated.
#
# html_domain_indices = True
# If false, no index is generated.
#
# html_use_index = True
# If true, the index is split into individual pages for each letter.
#
# html_split_index = False
# If true, links to the reST sources are added to the pages.
#
# html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr', 'zh'
#
# html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# 'ja' uses this config value.
# 'zh' user can custom change `jieba` dictionary path.
#
# html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#
# html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'Mymoduledoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'Mymodule.tex', 'My Module Documentation',
'Raphaël Doursenaud \\textless{}rdoursenaud@gpcsolutions.fr\\textgreater{}', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#
# latex_use_parts = False
# If true, show page references after internal links.
#
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
#
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
#
# latex_appendices = []
# It false, will not define \strong, \code, itleref, \crossref ... but only
# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
# packages.
#
# latex_keep_old_macro_names = True
# If false, no module index is generated.
#
# latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'mymodule', 'My Module Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#
# man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'Mymodule', 'My Module Documentation',
author, 'Mymodule', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#
# texinfo_appendices = []
# If false, no module index is generated.
#
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#
# texinfo_no_detailmenu = False
# -- Options for Epub output ----------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright
# The basename for the epub file. It defaults to the project name.
# epub_basename = project
# The HTML theme for the epub output. Since the default themes are not
# optimized for small screen space, using the same theme for HTML and epub
# output is usually not wise. This defaults to 'epub', a theme designed to save
# visual space.
#
# epub_theme = 'epub'
# The language of the text. It defaults to the language option
# or 'en' if the language is not set.
#
# epub_language = ''
# The scheme of the identifier. Typical schemes are ISBN or URL.
# epub_scheme = ''
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#
# epub_identifier = ''
# A unique identification for the text.
#
# epub_uid = ''
# A tuple containing the cover image and cover page html template filenames.
#
# epub_cover = ()
# A sequence of (type, uri, title) tuples for the guide element of content.opf.
#
# epub_guide = ()
# HTML files that should be inserted before the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#
# epub_pre_files = []
# HTML files that should be inserted after the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#
# epub_post_files = []
# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']
# The depth of the table of contents in toc.ncx.
#
# epub_tocdepth = 3
# Allow duplicate toc entries.
#
# epub_tocdup = True
# Choose between 'default' and 'includehidden'.
#
# epub_tocscope = 'default'
# Fix unsupported image types using the Pillow.
#
# epub_fix_images = False
# Scale large images.
#
# epub_max_image_width = 0
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#
# epub_show_urls = 'inline'
# If false, no index is generated.
#
# epub_use_index = True
| gpl-3.0 |
ddnbgroup/ansible | lib/ansible/plugins/lookup/flattened.py | 103 | 2506 | # (c) 2013, Serge van Ginderachter <serge@vanginderachter.be>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
from ansible.errors import *
from ansible.plugins.lookup import LookupBase
from ansible.utils.listify import listify_lookup_plugin_terms
class LookupModule(LookupBase):
def _check_list_of_one_list(self, term):
# make sure term is not a list of one (list of one..) item
# return the final non list item if so
if isinstance(term,list) and len(term) == 1:
term = term[0]
if isinstance(term,list):
term = self._check_list_of_one_list(term)
return term
def _do_flatten(self, terms, variables):
ret = []
for term in terms:
term = self._check_list_of_one_list(term)
if term == 'None' or term == 'null':
# ignore undefined items
break
if isinstance(term, basestring):
# convert a variable to a list
term2 = listify_lookup_plugin_terms(term, templar=self._templar, loader=self._loader)
# but avoid converting a plain string to a list of one string
if term2 != [ term ]:
term = term2
if isinstance(term, list):
# if it's a list, check recursively for items that are a list
term = self._do_flatten(term, variables)
ret.extend(term)
else:
ret.append(term)
return ret
def run(self, terms, variables, **kwargs):
### FIXME: Is this needed now that listify is run on all lookup plugin terms?
if not isinstance(terms, list):
raise AnsibleError("with_flattened expects a list")
return self._do_flatten(terms, variables)
| gpl-3.0 |
hfeeki/transifex | transifex/addons/gtranslate/tests.py | 1 | 2998 | # -*- coding: utf-8 -*-
from django.conf import settings
from transifex.txcommon.tests.base import BaseTestCase
from transifex.projects.models import Project
from handlers import *
from models import Gtranslate
from transifex.addons.gtranslate import is_gtranslate_allowed
class TestGtranslate(BaseTestCase):
def test_is_allowed(self):
"""Test if gtranslate is allowed for a particular project."""
outp = Project.objects.create(slug='outsourced', name='outsourced')
self.assertTrue(is_gtranslate_allowed(self.project))
Gtranslate.objects.create(use_gtranslate=True, project=self.project)
self.assertTrue(is_gtranslate_allowed(self.project))
self.project.outsource = outp
self.project.save()
self.assertTrue(is_gtranslate_allowed(self.project))
Gtranslate.objects.create(use_gtranslate=True, project=outp)
self.assertTrue(is_gtranslate_allowed(self.project))
def test_is_not_allowed(self):
"""Test if gtranslate is not allowed for a particular project."""
outp = Project.objects.create(slug='outsource', name='outsource')
g = Gtranslate.objects.create(use_gtranslate=False, project=self.project)
self.assertFalse(is_gtranslate_allowed(self.project))
self.project.outsource = outp
self.project.save()
self.assertFalse(is_gtranslate_allowed(self.project))
Gtranslate.objects.create(use_gtranslate=False, project=outp)
self.assertFalse(is_gtranslate_allowed(self.project))
g1 = Gtranslate.objects.get(project=outp)
g1.use_gtranslate=True
g1.save()
self.assertFalse(is_gtranslate_allowed(self.project))
g.use_translate = True
g.save()
g1.use_translate = False
g1.save()
self.assertFalse(is_gtranslate_allowed(self.project))
def test_delete(self):
"""Test, if a gtranslate entry is deleted, when the corresponding
project is delete.
"""
p = Project(slug="rm")
p.name = "RM me"
p.save()
Gtranslate.objects.create(use_gtranslate=False, project=p)
delete_gtranslate(p)
def test_projects_not_in_gtranslate_table(self):
"""Test the number of projects which are not in Gtranslate table"""
self.test_is_allowed()
projects_list = []
for p in Project.objects.all():
try:
Gtranslate.objects.get(project=p)
except:
projects_list.append(p)
self.assertEqual(len(projects_list), 6)
def test_default(self):
"""Test what happens when a project (or its outsource) are not
in the gtranslate table.
"""
self.assertTrue(is_gtranslate_allowed(self.project))
outp = Project.objects.create(
slug='outp', name='A new project'
)
self.project.outsource = outp
self.project.save()
self.assertTrue(is_gtranslate_allowed(self.project))
| gpl-2.0 |
thiderman/piper | piper/api.py | 1 | 5695 | import asyncio
import blessings
import json
import logbook
import types
from aiohttp import web
from piper.db.core import LazyDatabaseMixin
from piper import config
class ApiCLI(LazyDatabaseMixin):
_modules = None
config_class = config.AgentConfig
def __init__(self, config):
self.config = config
self.log = logbook.Logger(self.__class__.__name__)
def compose(self, parser): # pragma: nocover
api = parser.add_parser('api', help='Control the REST API')
sub = api.add_subparsers(help='API commands', dest="api_command")
sub.add_parser('start', help='Start the API')
return 'api', self.run
@property
def modules(self): # pragma: nocover
"""
Get a tuple of the modules that should be in the API.
This should probably be programmatically built rather than statically.
"""
if self._modules is not None:
return self._modules
from piper.agent import AgentAPI
from piper.build import BuildAPI
return (
AgentAPI(self.config),
BuildAPI(self.config),
)
@asyncio.coroutine
def setup_loop(self, loop):
app = web.Application(loop=loop)
for mod in self.modules:
mod.setup(app)
srv = yield from loop.create_server(
app.make_handler(),
self.config.raw['api']['address'],
self.config.raw['api']['port'],
)
self.log.info(
"Server started at http://{address}:{port}".format(
**self.config.raw['api']
)
)
return srv
def setup(self): # pragma: nocover
loop = asyncio.get_event_loop()
setup_future = self.setup_loop(loop)
loop.run_until_complete(setup_future)
return loop
def run(self, ns):
loop = self.setup()
loop.run_forever()
class RESTful(LazyDatabaseMixin):
"""
Abstract class pertaining to a RESTful API endpoint for aiohttp.
Anything that inherits for this has to set `self.routes` to be a tuple like
.. code-block::
routes = (
("POST", "/foo", self.post),
("GET", "/foo", self.get),
)
When :func:`setup` is ran, the routes will be added to the aiohttp app.
See :class:`piper.build.BuildAPI` for an example implementation.
"""
def __init__(self, config):
self.config = config
self.t = blessings.Terminal()
self.log = logbook.Logger(self.__class__.__name__)
def setup(self, app):
"""
Register the routes to the application.
Will decorate all methods with :func:`endpoint`
"""
for method, route, function in self.routes:
app.router.add_route(
method,
route,
self.endpoint(function, method, route),
)
def endpoint(self, func, method, route):
"""
Decorator method that takes care of calling and post processing
responses.
"""
def wrap(*args, **kwargs):
uri = route.format(**args[0].match_info)
self.log.debug(
'{t.bold_black}>>{t.white} {method} {t.normal}{uri}'.format(
method=method,
uri=uri,
t=self.t
)
)
body = func(*args, **kwargs)
code = 200
# POST requests will need to read from asyncio interfaces, and thus
# their handler functions will need to `yield from` and return
# generator objects. If this is the case, we need to yield from
# them to get the actual body out of there.
if isinstance(body, types.GeneratorType): # pragma: nocover
body = yield from body
# TODO: Add JSONschema validation
if isinstance(body, tuple):
# If the result was a 2-tuple, use the second item as the
# status code.
body, code = body
s = '{t.bold_black}<<{t.white} {method} {t.normal}{uri}: {code}'
self.log.info(
s.format(
method=method,
uri=uri,
code=code,
t=self.t
)
)
return self.encode_response(body, code)
return asyncio.coroutine(wrap)
def encode_response(self, body, code):
# TODO: Add **headers argument
body = json.dumps(
body,
indent=2,
sort_keys=True,
default=date_handler,
)
response = web.Response(
body=body.encode(),
status=code,
headers={'content-type': 'application/json'}
)
return response
def extract_json(self, request): # pragma: nocover
"""
Read the POST body of the request, decode it as JSON and return it.
:return: JSON-loaded dict of the POST body
"""
content = yield from request.content.read()
body = content.decode('utf-8')
self.log.debug(body)
data = json.loads(body)
return data
def date_handler(obj): # pragma: nocover
"""
This is why we cannot have nice things.
https://stackoverflow.com/questions/455580/
"""
if hasattr(obj, 'isoformat'):
return obj.isoformat()
elif isinstance(obj, ...):
return ...
else:
raise TypeError(
'Object of type %s with value of %s is not JSON serializable' % (
type(obj), repr(obj)
)
)
| mit |
stormi/tsunami | src/primaires/salle/commandes/deverrouiller/__init__.py | 1 | 3624 | # -*-coding:Utf-8 -*
# Copyright (c) 2010 LE GOFF Vincent
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""Package contenant la commande 'deverrouiller'."""
from primaires.interpreteur.commande.commande import Commande
from primaires.interpreteur.masque.exceptions.erreur_interpretation import \
ErreurInterpretation
class CmdDeverrouiller(Commande):
"""Commande 'deverrouiller'"""
def __init__(self):
"""Constructeur de la commande"""
Commande.__init__(self, "deverrouiller", "unlock")
self.nom_categorie = "bouger"
self.schema = "<nom_sortie>"
self.aide_courte = "déverrouille une porte"
self.aide_longue = \
"Cette commande déverrouille une porte de la salle où vous vous " \
"trouvez, à condition que vous ayez équipé la clef de la porte " \
"en question."
def interpreter(self, personnage, dic_masques):
"""Méthode d'interprétation de commande"""
sortie = dic_masques["nom_sortie"].sortie
salle = personnage.salle
nom_complet = sortie.nom_complet.capitalize()
personnage.agir("ouvrir")
if not sortie.porte:
raise ErreurInterpretation(
"|err|Cette sortie n'est pas une porte.|ff|")
if not sortie.porte.verrouillee:
raise ErreurInterpretation("Cette porte est déjà déverrouillée.")
if not sortie.porte.serrure:
raise ErreurInterpretation("Cette porte n'a pas de serrure.")
if not sortie.porte.clef in [o.prototype for o in \
personnage.equipement.equipes] and not personnage.est_immortel():
raise ErreurInterpretation("Vous n'avez pas la clef.")
sortie.porte.deverrouiller()
if personnage.est_immortel():
personnage << "Vos doigts étincellent un instant et un déclic " \
"d'ouverture se fait entendre."
else:
personnage << "Vous tournez la clef dans la serrure et entendez " \
"un déclic léger."
salle.envoyer("{{}} déverrouille {}.".format(sortie.nom_complet),
personnage)
| bsd-3-clause |
School-of-Innovation-Experiment/InnovationManagement | debug_toolbar/utils/sqlparse/__init__.py | 12 | 1457 | # Copyright (C) 2008 Andi Albrecht, albrecht.andi@gmail.com
#
# This module is part of python-sqlparse and is released under
# the BSD License: http://www.opensource.org/licenses/bsd-license.php.
"""Parse SQL statements."""
__version__ = '0.1.3'
class SQLParseError(Exception):
"""Base class for exceptions in this module."""
# Setup namespace
from debug_toolbar.utils.sqlparse import engine
from debug_toolbar.utils.sqlparse import filters
from debug_toolbar.utils.sqlparse import formatter
def parse(sql):
"""Parse sql and return a list of statements.
*sql* is a single string containting one or more SQL statements.
Returns a tuple of :class:`~sqlparse.sql.Statement` instances.
"""
stack = engine.FilterStack()
stack.full_analyze()
return tuple(stack.run(sql))
def format(sql, **options):
"""Format *sql* according to *options*.
Available options are documented in :ref:`formatting`.
Returns the formatted SQL statement as string.
"""
stack = engine.FilterStack()
options = formatter.validate_options(options)
stack = formatter.build_filter_stack(stack, options)
stack.postprocess.append(filters.SerializerUnicode())
return ''.join(stack.run(sql))
def split(sql):
"""Split *sql* into single statements.
Returns a list of strings.
"""
stack = engine.FilterStack()
stack.split_statements = True
return [unicode(stmt) for stmt in stack.run(sql)]
| agpl-3.0 |
yprez/python-social-auth | social/actions.py | 1 | 4703 | from social.p3 import quote
from social.utils import sanitize_redirect, user_is_authenticated, \
user_is_active, partial_pipeline_data, setting_url
def do_auth(backend, redirect_name='next'):
# Save any defined next value into session
data = backend.strategy.request_data(merge=False)
# Save extra data into session.
for field_name in backend.setting('FIELDS_STORED_IN_SESSION', []):
if field_name in data:
backend.strategy.session_set(field_name, data[field_name])
if redirect_name in data:
# Check and sanitize a user-defined GET/POST next field value
redirect_uri = data[redirect_name]
if backend.setting('SANITIZE_REDIRECTS', True):
redirect_uri = sanitize_redirect(backend.strategy.request_host(),
redirect_uri)
backend.strategy.session_set(
redirect_name,
redirect_uri or backend.setting('LOGIN_REDIRECT_URL')
)
return backend.start()
def do_complete(backend, login, user=None, redirect_name='next',
*args, **kwargs):
data = backend.strategy.request_data()
is_authenticated = user_is_authenticated(user)
user = is_authenticated and user or None
partial = partial_pipeline_data(backend, user, *args, **kwargs)
if partial:
xargs, xkwargs = partial
user = backend.continue_pipeline(*xargs, **xkwargs)
else:
user = backend.complete(user=user, *args, **kwargs)
# pop redirect value before the session is trashed on login(), but after
# the pipeline so that the pipeline can change the redirect if needed
redirect_value = backend.strategy.session_get(redirect_name, '') or \
data.get(redirect_name, '')
user_model = backend.strategy.storage.user.user_model()
if user and not isinstance(user, user_model):
return user
if is_authenticated:
if not user:
url = setting_url(backend, redirect_value, 'LOGIN_REDIRECT_URL')
else:
url = setting_url(backend, redirect_value,
'NEW_ASSOCIATION_REDIRECT_URL',
'LOGIN_REDIRECT_URL')
elif user:
if user_is_active(user):
# catch is_new/social_user in case login() resets the instance
is_new = getattr(user, 'is_new', False)
social_user = user.social_user
login(backend, user, social_user)
# store last login backend name in session
backend.strategy.session_set('social_auth_last_login_backend',
social_user.provider)
if is_new:
url = setting_url(backend,
'NEW_USER_REDIRECT_URL',
redirect_value,
'LOGIN_REDIRECT_URL')
else:
url = setting_url(backend, redirect_value,
'LOGIN_REDIRECT_URL')
else:
if backend.setting('INACTIVE_USER_LOGIN', False):
social_user = user.social_user
login(backend, user, social_user)
url = setting_url(backend, 'INACTIVE_USER_URL', 'LOGIN_ERROR_URL',
'LOGIN_URL')
else:
url = setting_url(backend, 'LOGIN_ERROR_URL', 'LOGIN_URL')
if redirect_value and redirect_value != url:
redirect_value = quote(redirect_value)
url += ('?' in url and '&' or '?') + \
'{0}={1}'.format(redirect_name, redirect_value)
if backend.setting('SANITIZE_REDIRECTS', True):
url = sanitize_redirect(backend.strategy.request_host(), url) or \
backend.setting('LOGIN_REDIRECT_URL')
return backend.strategy.redirect(url)
def do_disconnect(backend, user, association_id=None, redirect_name='next',
*args, **kwargs):
partial = partial_pipeline_data(backend, user, *args, **kwargs)
if partial:
xargs, xkwargs = partial
if association_id and not xkwargs.get('association_id'):
xkwargs['association_id'] = association_id
response = backend.disconnect(*xargs, **xkwargs)
else:
response = backend.disconnect(user=user, association_id=association_id,
*args, **kwargs)
if isinstance(response, dict):
response = backend.strategy.redirect(
backend.strategy.request_data().get(redirect_name, '') or
backend.setting('DISCONNECT_REDIRECT_URL') or
backend.setting('LOGIN_REDIRECT_URL')
)
return response
| bsd-3-clause |
jhawkesworth/ansible | lib/ansible/modules/network/fortios/fortios_ssh_filter_profile.py | 19 | 12364 | #!/usr/bin/python
from __future__ import (absolute_import, division, print_function)
# Copyright 2019 Fortinet, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
# the lib use python logging can get it if the following is set in your
# Ansible config.
__metaclass__ = type
ANSIBLE_METADATA = {'status': ['preview'],
'supported_by': 'community',
'metadata_version': '1.1'}
DOCUMENTATION = '''
---
module: fortios_ssh_filter_profile
short_description: SSH filter profile in Fortinet's FortiOS and FortiGate.
description:
- This module is able to configure a FortiGate or FortiOS by allowing the
user to set and modify ssh_filter feature and profile category.
Examples include all parameters and values need to be adjusted to datasources before usage.
Tested with FOS v6.0.2
version_added: "2.8"
author:
- Miguel Angel Munoz (@mamunozgonzalez)
- Nicolas Thomas (@thomnico)
notes:
- Requires fortiosapi library developed by Fortinet
- Run as a local_action in your playbook
requirements:
- fortiosapi>=0.9.8
options:
host:
description:
- FortiOS or FortiGate ip address.
required: true
username:
description:
- FortiOS or FortiGate username.
required: true
password:
description:
- FortiOS or FortiGate password.
default: ""
vdom:
description:
- Virtual domain, among those defined previously. A vdom is a
virtual instance of the FortiGate that can be configured and
used as a different unit.
default: root
https:
description:
- Indicates if the requests towards FortiGate must use HTTPS
protocol
type: bool
default: true
ssh_filter_profile:
description:
- SSH filter profile.
default: null
suboptions:
state:
description:
- Indicates whether to create or remove the object
choices:
- present
- absent
block:
description:
- SSH blocking options.
choices:
- x11
- shell
- exec
- port-forward
- tun-forward
- sftp
- unknown
default-command-log:
description:
- Enable/disable logging unmatched shell commands.
choices:
- enable
- disable
log:
description:
- SSH logging options.
choices:
- x11
- shell
- exec
- port-forward
- tun-forward
- sftp
- unknown
name:
description:
- SSH filter profile name.
required: true
shell-commands:
description:
- SSH command filter.
suboptions:
action:
description:
- Action to take for URL filter matches.
choices:
- block
- allow
alert:
description:
- Enable/disable alert.
choices:
- enable
- disable
id:
description:
- Id.
required: true
log:
description:
- Enable/disable logging.
choices:
- enable
- disable
pattern:
description:
- SSH shell command pattern.
severity:
description:
- Log severity.
choices:
- low
- medium
- high
- critical
type:
description:
- Matching type.
choices:
- simple
- regex
'''
EXAMPLES = '''
- hosts: localhost
vars:
host: "192.168.122.40"
username: "admin"
password: ""
vdom: "root"
tasks:
- name: SSH filter profile.
fortios_ssh_filter_profile:
host: "{{ host }}"
username: "{{ username }}"
password: "{{ password }}"
vdom: "{{ vdom }}"
https: "False"
ssh_filter_profile:
state: "present"
block: "x11"
default-command-log: "enable"
log: "x11"
name: "default_name_6"
shell-commands:
-
action: "block"
alert: "enable"
id: "10"
log: "enable"
pattern: "<your_own_value>"
severity: "low"
type: "simple"
'''
RETURN = '''
build:
description: Build number of the fortigate image
returned: always
type: str
sample: '1547'
http_method:
description: Last method used to provision the content into FortiGate
returned: always
type: str
sample: 'PUT'
http_status:
description: Last result given by FortiGate on last operation applied
returned: always
type: str
sample: "200"
mkey:
description: Master key (id) used in the last call to FortiGate
returned: success
type: str
sample: "id"
name:
description: Name of the table used to fulfill the request
returned: always
type: str
sample: "urlfilter"
path:
description: Path of the table used to fulfill the request
returned: always
type: str
sample: "webfilter"
revision:
description: Internal revision number
returned: always
type: str
sample: "17.0.2.10658"
serial:
description: Serial number of the unit
returned: always
type: str
sample: "FGVMEVYYQT3AB5352"
status:
description: Indication of the operation's result
returned: always
type: str
sample: "success"
vdom:
description: Virtual domain used
returned: always
type: str
sample: "root"
version:
description: Version of the FortiGate
returned: always
type: str
sample: "v5.6.3"
'''
from ansible.module_utils.basic import AnsibleModule
fos = None
def login(data):
host = data['host']
username = data['username']
password = data['password']
fos.debug('on')
if 'https' in data and not data['https']:
fos.https('off')
else:
fos.https('on')
fos.login(host, username, password)
def filter_ssh_filter_profile_data(json):
option_list = ['block', 'default-command-log', 'log',
'name', 'shell-commands']
dictionary = {}
for attribute in option_list:
if attribute in json and json[attribute] is not None:
dictionary[attribute] = json[attribute]
return dictionary
def flatten_multilists_attributes(data):
multilist_attrs = []
for attr in multilist_attrs:
try:
path = "data['" + "']['".join(elem for elem in attr) + "']"
current_val = eval(path)
flattened_val = ' '.join(elem for elem in current_val)
exec(path + '= flattened_val')
except BaseException:
pass
return data
def ssh_filter_profile(data, fos):
vdom = data['vdom']
ssh_filter_profile_data = data['ssh_filter_profile']
flattened_data = flatten_multilists_attributes(ssh_filter_profile_data)
filtered_data = filter_ssh_filter_profile_data(flattened_data)
if ssh_filter_profile_data['state'] == "present":
return fos.set('ssh-filter',
'profile',
data=filtered_data,
vdom=vdom)
elif ssh_filter_profile_data['state'] == "absent":
return fos.delete('ssh-filter',
'profile',
mkey=filtered_data['name'],
vdom=vdom)
def fortios_ssh_filter(data, fos):
login(data)
if data['ssh_filter_profile']:
resp = ssh_filter_profile(data, fos)
fos.logout()
return not resp['status'] == "success", resp['status'] == "success", resp
def main():
fields = {
"host": {"required": True, "type": "str"},
"username": {"required": True, "type": "str"},
"password": {"required": False, "type": "str", "no_log": True},
"vdom": {"required": False, "type": "str", "default": "root"},
"https": {"required": False, "type": "bool", "default": True},
"ssh_filter_profile": {
"required": False, "type": "dict",
"options": {
"state": {"required": True, "type": "str",
"choices": ["present", "absent"]},
"block": {"required": False, "type": "str",
"choices": ["x11", "shell", "exec",
"port-forward", "tun-forward", "sftp",
"unknown"]},
"default-command-log": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"log": {"required": False, "type": "str",
"choices": ["x11", "shell", "exec",
"port-forward", "tun-forward", "sftp",
"unknown"]},
"name": {"required": True, "type": "str"},
"shell-commands": {"required": False, "type": "list",
"options": {
"action": {"required": False, "type": "str",
"choices": ["block", "allow"]},
"alert": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"id": {"required": True, "type": "int"},
"log": {"required": False, "type": "str",
"choices": ["enable", "disable"]},
"pattern": {"required": False, "type": "str"},
"severity": {"required": False, "type": "str",
"choices": ["low", "medium", "high",
"critical"]},
"type": {"required": False, "type": "str",
"choices": ["simple", "regex"]}
}}
}
}
}
module = AnsibleModule(argument_spec=fields,
supports_check_mode=False)
try:
from fortiosapi import FortiOSAPI
except ImportError:
module.fail_json(msg="fortiosapi module is required")
global fos
fos = FortiOSAPI()
is_error, has_changed, result = fortios_ssh_filter(module.params, fos)
if not is_error:
module.exit_json(changed=has_changed, meta=result)
else:
module.fail_json(msg="Error in repo", meta=result)
if __name__ == '__main__':
main()
| gpl-3.0 |
shacker/django | django/contrib/redirects/migrations/0001_initial.py | 69 | 1491 | from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('sites', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Redirect',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('site', models.ForeignKey(
to='sites.Site',
to_field='id',
on_delete=models.CASCADE,
verbose_name='site',
)),
('old_path', models.CharField(
help_text=(
"This should be an absolute path, excluding the domain name. Example: '/events/search/'."
), max_length=200, verbose_name='redirect from', db_index=True
)),
('new_path', models.CharField(
help_text="This can be either an absolute path (as above) or a full URL starting with 'http://'.",
max_length=200, verbose_name='redirect to', blank=True
)),
],
options={
'ordering': ('old_path',),
'unique_together': {('site', 'old_path')},
'db_table': 'django_redirect',
'verbose_name': 'redirect',
'verbose_name_plural': 'redirects',
},
bases=(models.Model,),
),
]
| bsd-3-clause |
tragiclifestories/django | tests/admin_custom_urls/tests.py | 276 | 6381 | from __future__ import unicode_literals
import datetime
from django.contrib.admin.utils import quote
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.template.response import TemplateResponse
from django.test import TestCase, override_settings
from .models import Action, Car, Person
@override_settings(PASSWORD_HASHERS=['django.contrib.auth.hashers.SHA1PasswordHasher'],
ROOT_URLCONF='admin_custom_urls.urls',)
class AdminCustomUrlsTest(TestCase):
"""
Remember that:
* The Action model has a CharField PK.
* The ModelAdmin for Action customizes the add_view URL, it's
'<app name>/<model name>/!add/'
"""
@classmethod
def setUpTestData(cls):
# password = "secret"
User.objects.create(
pk=100, username='super', first_name='Super', last_name='User', email='super@example.com',
password='sha1$995a3$6011485ea3834267d719b4c801409b8b1ddd0158', is_active=True, is_superuser=True,
is_staff=True, last_login=datetime.datetime(2007, 5, 30, 13, 20, 10),
date_joined=datetime.datetime(2007, 5, 30, 13, 20, 10)
)
Action.objects.create(name='delete', description='Remove things.')
Action.objects.create(name='rename', description='Gives things other names.')
Action.objects.create(name='add', description='Add things.')
Action.objects.create(name='path/to/file/', description="An action with '/' in its name.")
Action.objects.create(
name='path/to/html/document.html',
description='An action with a name similar to a HTML doc path.'
)
Action.objects.create(
name='javascript:alert(\'Hello world\');">Click here</a>',
description='An action with a name suspected of being a XSS attempt'
)
def setUp(self):
self.client.login(username='super', password='secret')
def test_basic_add_GET(self):
"""
Ensure GET on the add_view works.
"""
add_url = reverse('admin_custom_urls:admin_custom_urls_action_add')
self.assertTrue(add_url.endswith('/!add/'))
response = self.client.get(add_url)
self.assertIsInstance(response, TemplateResponse)
self.assertEqual(response.status_code, 200)
def test_add_with_GET_args(self):
"""
Ensure GET on the add_view plus specifying a field value in the query
string works.
"""
response = self.client.get(reverse('admin_custom_urls:admin_custom_urls_action_add'), {'name': 'My Action'})
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'value="My Action"')
def test_basic_add_POST(self):
"""
Ensure POST on add_view works.
"""
post_data = {
'_popup': '1',
"name": 'Action added through a popup',
"description": "Description of added action",
}
response = self.client.post(reverse('admin_custom_urls:admin_custom_urls_action_add'), post_data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'dismissAddRelatedObjectPopup')
self.assertContains(response, 'Action added through a popup')
def test_admin_URLs_no_clash(self):
"""
Test that some admin URLs work correctly.
"""
# Should get the change_view for model instance with PK 'add', not show
# the add_view
url = reverse('admin_custom_urls:%s_action_change' % Action._meta.app_label,
args=(quote('add'),))
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Change action')
# Should correctly get the change_view for the model instance with the
# funny-looking PK (the one with a 'path/to/html/document.html' value)
url = reverse('admin_custom_urls:%s_action_change' % Action._meta.app_label,
args=(quote("path/to/html/document.html"),))
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Change action')
self.assertContains(response, 'value="path/to/html/document.html"')
def test_post_save_add_redirect(self):
"""
Ensures that ModelAdmin.response_post_save_add() controls the
redirection after the 'Save' button has been pressed when adding a
new object.
Refs 8001, 18310, 19505.
"""
post_data = {'name': 'John Doe'}
self.assertEqual(Person.objects.count(), 0)
response = self.client.post(
reverse('admin_custom_urls:admin_custom_urls_person_add'), post_data)
persons = Person.objects.all()
self.assertEqual(len(persons), 1)
self.assertRedirects(
response, reverse('admin_custom_urls:admin_custom_urls_person_history', args=[persons[0].pk]))
def test_post_save_change_redirect(self):
"""
Ensures that ModelAdmin.response_post_save_change() controls the
redirection after the 'Save' button has been pressed when editing an
existing object.
Refs 8001, 18310, 19505.
"""
Person.objects.create(name='John Doe')
self.assertEqual(Person.objects.count(), 1)
person = Person.objects.all()[0]
post_data = {'name': 'Jack Doe'}
response = self.client.post(
reverse('admin_custom_urls:admin_custom_urls_person_change', args=[person.pk]), post_data)
self.assertRedirects(
response, reverse('admin_custom_urls:admin_custom_urls_person_delete', args=[person.pk]))
def test_post_url_continue(self):
"""
Ensures that the ModelAdmin.response_add()'s parameter `post_url_continue`
controls the redirection after an object has been created.
"""
post_data = {'name': 'SuperFast', '_continue': '1'}
self.assertEqual(Car.objects.count(), 0)
response = self.client.post(
reverse('admin_custom_urls:admin_custom_urls_car_add'), post_data)
cars = Car.objects.all()
self.assertEqual(len(cars), 1)
self.assertRedirects(
response, reverse('admin_custom_urls:admin_custom_urls_car_history', args=[cars[0].pk]))
| bsd-3-clause |
tiexinliu/odoo_addons | smile_script/tests/test_script.py | 5 | 1546 | # -*- encoding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2013 Smile (<http://www.smile.fr>). All Rights Reserved
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from openerp.tests.common import TransactionCase
class ScriptTest(TransactionCase):
def test_run(self):
script = self.env['smile.script'].create({
'name': 'Test',
'type': 'python',
'description': 'Test',
'code': """
result = ustr(self.env['res.partner'].search([]))
result += ustr(self.pool['res.partner'].search(cr, uid, [], context=context))
""",
})
script.with_context(do_not_use_new_cursor=True).run_test()
self.assertTrue(script.intervention_ids[0].state == 'done')
| agpl-3.0 |
ajayuranakar/django-blog | lib/python2.7/site-packages/django/db/models/fields/__init__.py | 47 | 88713 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import collections
import copy
import datetime
import decimal
import math
import uuid
import warnings
from base64 import b64decode, b64encode
from functools import total_ordering
from django import forms
from django.apps import apps
from django.conf import settings
from django.core import checks, exceptions, validators
# When the _meta object was formalized, this exception was moved to
# django.core.exceptions. It is retained here for backwards compatibility
# purposes.
from django.core.exceptions import FieldDoesNotExist # NOQA
from django.db import connection, connections, router
from django.db.models.query_utils import QueryWrapper, RegisterLookupMixin
from django.utils import six, timezone
from django.utils.datastructures import DictWrapper
from django.utils.dateparse import (
parse_date, parse_datetime, parse_duration, parse_time,
)
from django.utils.deprecation import (
RemovedInDjango20Warning, warn_about_renamed_method,
)
from django.utils.duration import duration_string
from django.utils.encoding import (
force_bytes, force_text, python_2_unicode_compatible, smart_text,
)
from django.utils.functional import Promise, cached_property, curry
from django.utils.ipv6 import clean_ipv6_address
from django.utils.itercompat import is_iterable
from django.utils.text import capfirst
from django.utils.translation import ugettext_lazy as _
# Avoid "TypeError: Item in ``from list'' not a string" -- unicode_literals
# makes these strings unicode
__all__ = [str(x) for x in (
'AutoField', 'BLANK_CHOICE_DASH', 'BigIntegerField', 'BinaryField',
'BooleanField', 'CharField', 'CommaSeparatedIntegerField', 'DateField',
'DateTimeField', 'DecimalField', 'DurationField', 'EmailField', 'Empty',
'Field', 'FieldDoesNotExist', 'FilePathField', 'FloatField',
'GenericIPAddressField', 'IPAddressField', 'IntegerField', 'NOT_PROVIDED',
'NullBooleanField', 'PositiveIntegerField', 'PositiveSmallIntegerField',
'SlugField', 'SmallIntegerField', 'TextField', 'TimeField', 'URLField',
'UUIDField',
)]
class Empty(object):
pass
class NOT_PROVIDED:
pass
# The values to use for "blank" in SelectFields. Will be appended to the start
# of most "choices" lists.
BLANK_CHOICE_DASH = [("", "---------")]
def _load_field(app_label, model_name, field_name):
return apps.get_model(app_label, model_name)._meta.get_field(field_name)
# A guide to Field parameters:
#
# * name: The name of the field specified in the model.
# * attname: The attribute to use on the model object. This is the same as
# "name", except in the case of ForeignKeys, where "_id" is
# appended.
# * db_column: The db_column specified in the model (or None).
# * column: The database column for this field. This is the same as
# "attname", except if db_column is specified.
#
# Code that introspects values, or does other dynamic things, should use
# attname. For example, this gets the primary key value of object "obj":
#
# getattr(obj, opts.pk.attname)
def _empty(of_cls):
new = Empty()
new.__class__ = of_cls
return new
@total_ordering
@python_2_unicode_compatible
class Field(RegisterLookupMixin):
"""Base class for all field types"""
# Designates whether empty strings fundamentally are allowed at the
# database level.
empty_strings_allowed = True
empty_values = list(validators.EMPTY_VALUES)
# These track each time a Field instance is created. Used to retain order.
# The auto_creation_counter is used for fields that Django implicitly
# creates, creation_counter is used for all user-specified fields.
creation_counter = 0
auto_creation_counter = -1
default_validators = [] # Default set of validators
default_error_messages = {
'invalid_choice': _('Value %(value)r is not a valid choice.'),
'null': _('This field cannot be null.'),
'blank': _('This field cannot be blank.'),
'unique': _('%(model_name)s with this %(field_label)s '
'already exists.'),
# Translators: The 'lookup_type' is one of 'date', 'year' or 'month'.
# Eg: "Title must be unique for pub_date year"
'unique_for_date': _("%(field_label)s must be unique for "
"%(date_field_label)s %(lookup_type)s."),
}
system_check_deprecated_details = None
system_check_removed_details = None
# Field flags
hidden = False
many_to_many = None
many_to_one = None
one_to_many = None
one_to_one = None
related_model = None
# Generic field type description, usually overridden by subclasses
def _description(self):
return _('Field of type: %(field_type)s') % {
'field_type': self.__class__.__name__
}
description = property(_description)
def __init__(self, verbose_name=None, name=None, primary_key=False,
max_length=None, unique=False, blank=False, null=False,
db_index=False, rel=None, default=NOT_PROVIDED, editable=True,
serialize=True, unique_for_date=None, unique_for_month=None,
unique_for_year=None, choices=None, help_text='', db_column=None,
db_tablespace=None, auto_created=False, validators=[],
error_messages=None):
self.name = name
self.verbose_name = verbose_name # May be set by set_attributes_from_name
self._verbose_name = verbose_name # Store original for deconstruction
self.primary_key = primary_key
self.max_length, self._unique = max_length, unique
self.blank, self.null = blank, null
self.remote_field = rel
self.is_relation = self.remote_field is not None
self.default = default
self.editable = editable
self.serialize = serialize
self.unique_for_date = unique_for_date
self.unique_for_month = unique_for_month
self.unique_for_year = unique_for_year
if isinstance(choices, collections.Iterator):
choices = list(choices)
self.choices = choices or []
self.help_text = help_text
self.db_index = db_index
self.db_column = db_column
self.db_tablespace = db_tablespace or settings.DEFAULT_INDEX_TABLESPACE
self.auto_created = auto_created
# Adjust the appropriate creation counter, and save our local copy.
if auto_created:
self.creation_counter = Field.auto_creation_counter
Field.auto_creation_counter -= 1
else:
self.creation_counter = Field.creation_counter
Field.creation_counter += 1
self._validators = validators # Store for deconstruction later
messages = {}
for c in reversed(self.__class__.__mro__):
messages.update(getattr(c, 'default_error_messages', {}))
messages.update(error_messages or {})
self._error_messages = error_messages # Store for deconstruction later
self.error_messages = messages
def __str__(self):
""" Return "app_label.model_label.field_name". """
model = self.model
app = model._meta.app_label
return '%s.%s.%s' % (app, model._meta.object_name, self.name)
def __repr__(self):
"""
Displays the module, class and name of the field.
"""
path = '%s.%s' % (self.__class__.__module__, self.__class__.__name__)
name = getattr(self, 'name', None)
if name is not None:
return '<%s: %s>' % (path, name)
return '<%s>' % path
def check(self, **kwargs):
errors = []
errors.extend(self._check_field_name())
errors.extend(self._check_choices())
errors.extend(self._check_db_index())
errors.extend(self._check_null_allowed_for_primary_keys())
errors.extend(self._check_backend_specific_checks(**kwargs))
errors.extend(self._check_deprecation_details())
return errors
def _check_field_name(self):
""" Check if field name is valid, i.e. 1) does not end with an
underscore, 2) does not contain "__" and 3) is not "pk". """
if self.name.endswith('_'):
return [
checks.Error(
'Field names must not end with an underscore.',
hint=None,
obj=self,
id='fields.E001',
)
]
elif '__' in self.name:
return [
checks.Error(
'Field names must not contain "__".',
hint=None,
obj=self,
id='fields.E002',
)
]
elif self.name == 'pk':
return [
checks.Error(
"'pk' is a reserved word that cannot be used as a field name.",
hint=None,
obj=self,
id='fields.E003',
)
]
else:
return []
@property
def rel(self):
warnings.warn(
"Usage of field.rel has been deprecated. Use field.remote_field instead.",
RemovedInDjango20Warning, 2)
return self.remote_field
def _check_choices(self):
if self.choices:
if (isinstance(self.choices, six.string_types) or
not is_iterable(self.choices)):
return [
checks.Error(
"'choices' must be an iterable (e.g., a list or tuple).",
hint=None,
obj=self,
id='fields.E004',
)
]
elif any(isinstance(choice, six.string_types) or
not is_iterable(choice) or len(choice) != 2
for choice in self.choices):
return [
checks.Error(
("'choices' must be an iterable containing "
"(actual value, human readable name) tuples."),
hint=None,
obj=self,
id='fields.E005',
)
]
else:
return []
else:
return []
def _check_db_index(self):
if self.db_index not in (None, True, False):
return [
checks.Error(
"'db_index' must be None, True or False.",
hint=None,
obj=self,
id='fields.E006',
)
]
else:
return []
def _check_null_allowed_for_primary_keys(self):
if (self.primary_key and self.null and
not connection.features.interprets_empty_strings_as_nulls):
# We cannot reliably check this for backends like Oracle which
# consider NULL and '' to be equal (and thus set up
# character-based fields a little differently).
return [
checks.Error(
'Primary keys must not have null=True.',
hint=('Set null=False on the field, or '
'remove primary_key=True argument.'),
obj=self,
id='fields.E007',
)
]
else:
return []
def _check_backend_specific_checks(self, **kwargs):
app_label = self.model._meta.app_label
for db in connections:
if router.allow_migrate(db, app_label, model=self.model):
return connections[db].validation.check_field(self, **kwargs)
return []
def _check_deprecation_details(self):
if self.system_check_removed_details is not None:
return [
checks.Error(
self.system_check_removed_details.get(
'msg',
'%s has been removed except for support in historical '
'migrations.' % self.__class__.__name__
),
hint=self.system_check_removed_details.get('hint'),
obj=self,
id=self.system_check_removed_details.get('id', 'fields.EXXX'),
)
]
elif self.system_check_deprecated_details is not None:
return [
checks.Warning(
self.system_check_deprecated_details.get(
'msg',
'%s has been deprecated.' % self.__class__.__name__
),
hint=self.system_check_deprecated_details.get('hint'),
obj=self,
id=self.system_check_deprecated_details.get('id', 'fields.WXXX'),
)
]
return []
def get_col(self, alias, output_field=None):
if output_field is None:
output_field = self
if alias != self.model._meta.db_table or output_field != self:
from django.db.models.expressions import Col
return Col(alias, self, output_field)
else:
return self.cached_col
@cached_property
def cached_col(self):
from django.db.models.expressions import Col
return Col(self.model._meta.db_table, self)
def select_format(self, compiler, sql, params):
"""
Custom format for select clauses. For example, GIS columns need to be
selected as AsText(table.col) on MySQL as the table.col data can't be used
by Django.
"""
return sql, params
def deconstruct(self):
"""
Returns enough information to recreate the field as a 4-tuple:
* The name of the field on the model, if contribute_to_class has been run
* The import path of the field, including the class: django.db.models.IntegerField
This should be the most portable version, so less specific may be better.
* A list of positional arguments
* A dict of keyword arguments
Note that the positional or keyword arguments must contain values of the
following types (including inner values of collection types):
* None, bool, str, unicode, int, long, float, complex, set, frozenset, list, tuple, dict
* UUID
* datetime.datetime (naive), datetime.date
* top-level classes, top-level functions - will be referenced by their full import path
* Storage instances - these have their own deconstruct() method
This is because the values here must be serialized into a text format
(possibly new Python code, possibly JSON) and these are the only types
with encoding handlers defined.
There's no need to return the exact way the field was instantiated this time,
just ensure that the resulting field is the same - prefer keyword arguments
over positional ones, and omit parameters with their default values.
"""
# Short-form way of fetching all the default parameters
keywords = {}
possibles = {
"verbose_name": None,
"primary_key": False,
"max_length": None,
"unique": False,
"blank": False,
"null": False,
"db_index": False,
"default": NOT_PROVIDED,
"editable": True,
"serialize": True,
"unique_for_date": None,
"unique_for_month": None,
"unique_for_year": None,
"choices": [],
"help_text": '',
"db_column": None,
"db_tablespace": settings.DEFAULT_INDEX_TABLESPACE,
"auto_created": False,
"validators": [],
"error_messages": None,
}
attr_overrides = {
"unique": "_unique",
"error_messages": "_error_messages",
"validators": "_validators",
"verbose_name": "_verbose_name",
}
equals_comparison = {"choices", "validators", "db_tablespace"}
for name, default in possibles.items():
value = getattr(self, attr_overrides.get(name, name))
# Unroll anything iterable for choices into a concrete list
if name == "choices" and isinstance(value, collections.Iterable):
value = list(value)
# Do correct kind of comparison
if name in equals_comparison:
if value != default:
keywords[name] = value
else:
if value is not default:
keywords[name] = value
# Work out path - we shorten it for known Django core fields
path = "%s.%s" % (self.__class__.__module__, self.__class__.__name__)
if path.startswith("django.db.models.fields.related"):
path = path.replace("django.db.models.fields.related", "django.db.models")
if path.startswith("django.db.models.fields.files"):
path = path.replace("django.db.models.fields.files", "django.db.models")
if path.startswith("django.db.models.fields.proxy"):
path = path.replace("django.db.models.fields.proxy", "django.db.models")
if path.startswith("django.db.models.fields"):
path = path.replace("django.db.models.fields", "django.db.models")
# Return basic info - other fields should override this.
return (
force_text(self.name, strings_only=True),
path,
[],
keywords,
)
def clone(self):
"""
Uses deconstruct() to clone a new copy of this Field.
Will not preserve any class attachments/attribute names.
"""
name, path, args, kwargs = self.deconstruct()
return self.__class__(*args, **kwargs)
def __eq__(self, other):
# Needed for @total_ordering
if isinstance(other, Field):
return self.creation_counter == other.creation_counter
return NotImplemented
def __lt__(self, other):
# This is needed because bisect does not take a comparison function.
if isinstance(other, Field):
return self.creation_counter < other.creation_counter
return NotImplemented
def __hash__(self):
return hash(self.creation_counter)
def __deepcopy__(self, memodict):
# We don't have to deepcopy very much here, since most things are not
# intended to be altered after initial creation.
obj = copy.copy(self)
if self.remote_field:
obj.remote_field = copy.copy(self.remote_field)
if hasattr(self.remote_field, 'field') and self.remote_field.field is self:
obj.remote_field.field = obj
memodict[id(self)] = obj
return obj
def __copy__(self):
# We need to avoid hitting __reduce__, so define this
# slightly weird copy construct.
obj = Empty()
obj.__class__ = self.__class__
obj.__dict__ = self.__dict__.copy()
return obj
def __reduce__(self):
"""
Pickling should return the model._meta.fields instance of the field,
not a new copy of that field. So, we use the app registry to load the
model and then the field back.
"""
if not hasattr(self, 'model'):
# Fields are sometimes used without attaching them to models (for
# example in aggregation). In this case give back a plain field
# instance. The code below will create a new empty instance of
# class self.__class__, then update its dict with self.__dict__
# values - so, this is very close to normal pickle.
return _empty, (self.__class__,), self.__dict__
if self.model._deferred:
# Deferred model will not be found from the app registry. This
# could be fixed by reconstructing the deferred model on unpickle.
raise RuntimeError("Fields of deferred models can't be reduced")
return _load_field, (self.model._meta.app_label, self.model._meta.object_name,
self.name)
def get_pk_value_on_save(self, instance):
"""
Hook to generate new PK values on save. This method is called when
saving instances with no primary key value set. If this method returns
something else than None, then the returned value is used when saving
the new instance.
"""
if self.default:
return self.get_default()
return None
def to_python(self, value):
"""
Converts the input value into the expected Python data type, raising
django.core.exceptions.ValidationError if the data can't be converted.
Returns the converted value. Subclasses should override this.
"""
return value
@cached_property
def validators(self):
# Some validators can't be created at field initialization time.
# This method provides a way to delay their creation until required.
return self.default_validators + self._validators
def run_validators(self, value):
if value in self.empty_values:
return
errors = []
for v in self.validators:
try:
v(value)
except exceptions.ValidationError as e:
if hasattr(e, 'code') and e.code in self.error_messages:
e.message = self.error_messages[e.code]
errors.extend(e.error_list)
if errors:
raise exceptions.ValidationError(errors)
def validate(self, value, model_instance):
"""
Validates value and throws ValidationError. Subclasses should override
this to provide validation logic.
"""
if not self.editable:
# Skip validation for non-editable fields.
return
if self.choices and value not in self.empty_values:
for option_key, option_value in self.choices:
if isinstance(option_value, (list, tuple)):
# This is an optgroup, so look inside the group for
# options.
for optgroup_key, optgroup_value in option_value:
if value == optgroup_key:
return
elif value == option_key:
return
raise exceptions.ValidationError(
self.error_messages['invalid_choice'],
code='invalid_choice',
params={'value': value},
)
if value is None and not self.null:
raise exceptions.ValidationError(self.error_messages['null'], code='null')
if not self.blank and value in self.empty_values:
raise exceptions.ValidationError(self.error_messages['blank'], code='blank')
def clean(self, value, model_instance):
"""
Convert the value's type and run validation. Validation errors
from to_python and validate are propagated. The correct value is
returned if no error is raised.
"""
value = self.to_python(value)
self.validate(value, model_instance)
self.run_validators(value)
return value
def db_type(self, connection):
"""
Returns the database column data type for this field, for the provided
connection.
"""
# The default implementation of this method looks at the
# backend-specific data_types dictionary, looking up the field by its
# "internal type".
#
# A Field class can implement the get_internal_type() method to specify
# which *preexisting* Django Field class it's most similar to -- i.e.,
# a custom field might be represented by a TEXT column type, which is
# the same as the TextField Django field type, which means the custom
# field's get_internal_type() returns 'TextField'.
#
# But the limitation of the get_internal_type() / data_types approach
# is that it cannot handle database column types that aren't already
# mapped to one of the built-in Django field types. In this case, you
# can implement db_type() instead of get_internal_type() to specify
# exactly which wacky database column type you want to use.
data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
try:
return connection.data_types[self.get_internal_type()] % data
except KeyError:
return None
def db_parameters(self, connection):
"""
Extension of db_type(), providing a range of different return
values (type, checks).
This will look at db_type(), allowing custom model fields to override it.
"""
data = DictWrapper(self.__dict__, connection.ops.quote_name, "qn_")
type_string = self.db_type(connection)
try:
check_string = connection.data_type_check_constraints[self.get_internal_type()] % data
except KeyError:
check_string = None
return {
"type": type_string,
"check": check_string,
}
def db_type_suffix(self, connection):
return connection.data_types_suffix.get(self.get_internal_type())
def get_db_converters(self, connection):
if hasattr(self, 'from_db_value'):
return [self.from_db_value]
return []
@property
def unique(self):
return self._unique or self.primary_key
def set_attributes_from_name(self, name):
if not self.name:
self.name = name
self.attname, self.column = self.get_attname_column()
self.concrete = self.column is not None
if self.verbose_name is None and self.name:
self.verbose_name = self.name.replace('_', ' ')
def contribute_to_class(self, cls, name, virtual_only=False):
self.set_attributes_from_name(name)
self.model = cls
if virtual_only:
cls._meta.add_field(self, virtual=True)
else:
cls._meta.add_field(self)
if self.choices:
setattr(cls, 'get_%s_display' % self.name,
curry(cls._get_FIELD_display, field=self))
def get_filter_kwargs_for_object(self, obj):
"""
Return a dict that when passed as kwargs to self.model.filter(), would
yield all instances having the same value for this field as obj has.
"""
return {self.name: getattr(obj, self.attname)}
def get_attname(self):
return self.name
def get_attname_column(self):
attname = self.get_attname()
column = self.db_column or attname
return attname, column
def get_cache_name(self):
return '_%s_cache' % self.name
def get_internal_type(self):
return self.__class__.__name__
def pre_save(self, model_instance, add):
"""
Returns field's value just before saving.
"""
return getattr(model_instance, self.attname)
def get_prep_value(self, value):
"""
Perform preliminary non-db specific value checks and conversions.
"""
if isinstance(value, Promise):
value = value._proxy____cast()
return value
def get_db_prep_value(self, value, connection, prepared=False):
"""Returns field's value prepared for interacting with the database
backend.
Used by the default implementations of ``get_db_prep_save``and
`get_db_prep_lookup```
"""
if not prepared:
value = self.get_prep_value(value)
return value
def get_db_prep_save(self, value, connection):
"""
Returns field's value prepared for saving into a database.
"""
return self.get_db_prep_value(value, connection=connection,
prepared=False)
def get_prep_lookup(self, lookup_type, value):
"""
Perform preliminary non-db specific lookup checks and conversions
"""
if hasattr(value, '_prepare'):
return value._prepare()
if lookup_type in {
'iexact', 'contains', 'icontains',
'startswith', 'istartswith', 'endswith', 'iendswith',
'isnull', 'search', 'regex', 'iregex',
}:
return value
elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
return self.get_prep_value(value)
elif lookup_type in ('range', 'in'):
return [self.get_prep_value(v) for v in value]
return self.get_prep_value(value)
def get_db_prep_lookup(self, lookup_type, value, connection,
prepared=False):
"""
Returns field's value prepared for database lookup.
"""
if not prepared:
value = self.get_prep_lookup(lookup_type, value)
prepared = True
if hasattr(value, 'get_compiler'):
value = value.get_compiler(connection=connection)
if hasattr(value, 'as_sql') or hasattr(value, '_as_sql'):
# If the value has a relabeled_clone method it means the
# value will be handled later on.
if hasattr(value, 'relabeled_clone'):
return value
if hasattr(value, 'as_sql'):
sql, params = value.as_sql()
else:
sql, params = value._as_sql(connection=connection)
return QueryWrapper(('(%s)' % sql), params)
if lookup_type in ('search', 'regex', 'iregex', 'contains',
'icontains', 'iexact', 'startswith', 'endswith',
'istartswith', 'iendswith'):
return [value]
elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
return [self.get_db_prep_value(value, connection=connection,
prepared=prepared)]
elif lookup_type in ('range', 'in'):
return [self.get_db_prep_value(v, connection=connection,
prepared=prepared) for v in value]
elif lookup_type == 'isnull':
return []
else:
return [value]
def has_default(self):
"""
Returns a boolean of whether this field has a default value.
"""
return self.default is not NOT_PROVIDED
def get_default(self):
"""
Returns the default value for this field.
"""
if self.has_default():
if callable(self.default):
return self.default()
return self.default
if (not self.empty_strings_allowed or (self.null and
not connection.features.interprets_empty_strings_as_nulls)):
return None
return ""
def get_choices(self, include_blank=True, blank_choice=BLANK_CHOICE_DASH, limit_choices_to=None):
"""Returns choices with a default blank choices included, for use
as SelectField choices for this field."""
blank_defined = False
choices = list(self.choices) if self.choices else []
named_groups = choices and isinstance(choices[0][1], (list, tuple))
if not named_groups:
for choice, __ in choices:
if choice in ('', None):
blank_defined = True
break
first_choice = (blank_choice if include_blank and
not blank_defined else [])
if self.choices:
return first_choice + choices
rel_model = self.remote_field.model
limit_choices_to = limit_choices_to or self.get_limit_choices_to()
if hasattr(self.remote_field, 'get_related_field'):
lst = [(getattr(x, self.remote_field.get_related_field().attname),
smart_text(x))
for x in rel_model._default_manager.complex_filter(
limit_choices_to)]
else:
lst = [(x._get_pk_val(), smart_text(x))
for x in rel_model._default_manager.complex_filter(
limit_choices_to)]
return first_choice + lst
def get_choices_default(self):
return self.get_choices()
@warn_about_renamed_method(
'Field', '_get_val_from_obj', 'value_from_object',
RemovedInDjango20Warning
)
def _get_val_from_obj(self, obj):
if obj is not None:
return getattr(obj, self.attname)
else:
return self.get_default()
def value_to_string(self, obj):
"""
Returns a string value of this field from the passed obj.
This is used by the serialization framework.
"""
return smart_text(self.value_from_object(obj))
def _get_flatchoices(self):
"""Flattened version of choices tuple."""
flat = []
for choice, value in self.choices:
if isinstance(value, (list, tuple)):
flat.extend(value)
else:
flat.append((choice, value))
return flat
flatchoices = property(_get_flatchoices)
def save_form_data(self, instance, data):
setattr(instance, self.name, data)
def formfield(self, form_class=None, choices_form_class=None, **kwargs):
"""
Returns a django.forms.Field instance for this database Field.
"""
defaults = {'required': not self.blank,
'label': capfirst(self.verbose_name),
'help_text': self.help_text}
if self.has_default():
if callable(self.default):
defaults['initial'] = self.default
defaults['show_hidden_initial'] = True
else:
defaults['initial'] = self.get_default()
if self.choices:
# Fields with choices get special treatment.
include_blank = (self.blank or
not (self.has_default() or 'initial' in kwargs))
defaults['choices'] = self.get_choices(include_blank=include_blank)
defaults['coerce'] = self.to_python
if self.null:
defaults['empty_value'] = None
if choices_form_class is not None:
form_class = choices_form_class
else:
form_class = forms.TypedChoiceField
# Many of the subclass-specific formfield arguments (min_value,
# max_value) don't apply for choice fields, so be sure to only pass
# the values that TypedChoiceField will understand.
for k in list(kwargs):
if k not in ('coerce', 'empty_value', 'choices', 'required',
'widget', 'label', 'initial', 'help_text',
'error_messages', 'show_hidden_initial'):
del kwargs[k]
defaults.update(kwargs)
if form_class is None:
form_class = forms.CharField
return form_class(**defaults)
def value_from_object(self, obj):
"""
Returns the value of this field in the given model instance.
"""
return getattr(obj, self.attname)
class AutoField(Field):
description = _("Integer")
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value must be an integer."),
}
def __init__(self, *args, **kwargs):
kwargs['blank'] = True
super(AutoField, self).__init__(*args, **kwargs)
def check(self, **kwargs):
errors = super(AutoField, self).check(**kwargs)
errors.extend(self._check_primary_key())
return errors
def _check_primary_key(self):
if not self.primary_key:
return [
checks.Error(
'AutoFields must set primary_key=True.',
hint=None,
obj=self,
id='fields.E100',
),
]
else:
return []
def deconstruct(self):
name, path, args, kwargs = super(AutoField, self).deconstruct()
del kwargs['blank']
kwargs['primary_key'] = True
return name, path, args, kwargs
def get_internal_type(self):
return "AutoField"
def to_python(self, value):
if value is None:
return value
try:
return int(value)
except (TypeError, ValueError):
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def validate(self, value, model_instance):
pass
def get_db_prep_value(self, value, connection, prepared=False):
if not prepared:
value = self.get_prep_value(value)
value = connection.ops.validate_autopk_value(value)
return value
def get_prep_value(self, value):
value = super(AutoField, self).get_prep_value(value)
if value is None:
return None
return int(value)
def contribute_to_class(self, cls, name, **kwargs):
assert not cls._meta.has_auto_field, \
"A model can't have more than one AutoField."
super(AutoField, self).contribute_to_class(cls, name, **kwargs)
cls._meta.has_auto_field = True
cls._meta.auto_field = self
def formfield(self, **kwargs):
return None
class BooleanField(Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value must be either True or False."),
}
description = _("Boolean (Either True or False)")
def __init__(self, *args, **kwargs):
kwargs['blank'] = True
super(BooleanField, self).__init__(*args, **kwargs)
def check(self, **kwargs):
errors = super(BooleanField, self).check(**kwargs)
errors.extend(self._check_null(**kwargs))
return errors
def _check_null(self, **kwargs):
if getattr(self, 'null', False):
return [
checks.Error(
'BooleanFields do not accept null values.',
hint='Use a NullBooleanField instead.',
obj=self,
id='fields.E110',
)
]
else:
return []
def deconstruct(self):
name, path, args, kwargs = super(BooleanField, self).deconstruct()
del kwargs['blank']
return name, path, args, kwargs
def get_internal_type(self):
return "BooleanField"
def to_python(self, value):
if value in (True, False):
# if value is 1 or 0 than it's equal to True or False, but we want
# to return a true bool for semantic reasons.
return bool(value)
if value in ('t', 'True', '1'):
return True
if value in ('f', 'False', '0'):
return False
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def get_prep_lookup(self, lookup_type, value):
# Special-case handling for filters coming from a Web request (e.g. the
# admin interface). Only works for scalar values (not lists). If you're
# passing in a list, you might as well make things the right type when
# constructing the list.
if value in ('1', '0'):
value = bool(int(value))
return super(BooleanField, self).get_prep_lookup(lookup_type, value)
def get_prep_value(self, value):
value = super(BooleanField, self).get_prep_value(value)
if value is None:
return None
return bool(value)
def formfield(self, **kwargs):
# Unlike most fields, BooleanField figures out include_blank from
# self.null instead of self.blank.
if self.choices:
include_blank = not (self.has_default() or 'initial' in kwargs)
defaults = {'choices': self.get_choices(include_blank=include_blank)}
else:
defaults = {'form_class': forms.BooleanField}
defaults.update(kwargs)
return super(BooleanField, self).formfield(**defaults)
class CharField(Field):
description = _("String (up to %(max_length)s)")
def __init__(self, *args, **kwargs):
super(CharField, self).__init__(*args, **kwargs)
self.validators.append(validators.MaxLengthValidator(self.max_length))
def check(self, **kwargs):
errors = super(CharField, self).check(**kwargs)
errors.extend(self._check_max_length_attribute(**kwargs))
return errors
def _check_max_length_attribute(self, **kwargs):
if self.max_length is None:
return [
checks.Error(
"CharFields must define a 'max_length' attribute.",
hint=None,
obj=self,
id='fields.E120',
)
]
elif not isinstance(self.max_length, six.integer_types) or self.max_length <= 0:
return [
checks.Error(
"'max_length' must be a positive integer.",
hint=None,
obj=self,
id='fields.E121',
)
]
else:
return []
def get_internal_type(self):
return "CharField"
def to_python(self, value):
if isinstance(value, six.string_types) or value is None:
return value
return smart_text(value)
def get_prep_value(self, value):
value = super(CharField, self).get_prep_value(value)
return self.to_python(value)
def formfield(self, **kwargs):
# Passing max_length to forms.CharField means that the value's length
# will be validated twice. This is considered acceptable since we want
# the value in the form field (to pass into widget for example).
defaults = {'max_length': self.max_length}
defaults.update(kwargs)
return super(CharField, self).formfield(**defaults)
class CommaSeparatedIntegerField(CharField):
default_validators = [validators.validate_comma_separated_integer_list]
description = _("Comma-separated integers")
def formfield(self, **kwargs):
defaults = {
'error_messages': {
'invalid': _('Enter only digits separated by commas.'),
}
}
defaults.update(kwargs)
return super(CommaSeparatedIntegerField, self).formfield(**defaults)
class DateTimeCheckMixin(object):
def check(self, **kwargs):
errors = super(DateTimeCheckMixin, self).check(**kwargs)
errors.extend(self._check_mutually_exclusive_options())
errors.extend(self._check_fix_default_value())
return errors
def _check_mutually_exclusive_options(self):
# auto_now, auto_now_add, and default are mutually exclusive
# options. The use of more than one of these options together
# will trigger an Error
mutually_exclusive_options = [self.auto_now_add, self.auto_now,
self.has_default()]
enabled_options = [option not in (None, False)
for option in mutually_exclusive_options].count(True)
if enabled_options > 1:
return [
checks.Error(
"The options auto_now, auto_now_add, and default "
"are mutually exclusive. Only one of these options "
"may be present.",
hint=None,
obj=self,
id='fields.E160',
)
]
else:
return []
def _check_fix_default_value(self):
return []
class DateField(DateTimeCheckMixin, Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value has an invalid date format. It must be "
"in YYYY-MM-DD format."),
'invalid_date': _("'%(value)s' value has the correct format (YYYY-MM-DD) "
"but it is an invalid date."),
}
description = _("Date (without time)")
def __init__(self, verbose_name=None, name=None, auto_now=False,
auto_now_add=False, **kwargs):
self.auto_now, self.auto_now_add = auto_now, auto_now_add
if auto_now or auto_now_add:
kwargs['editable'] = False
kwargs['blank'] = True
super(DateField, self).__init__(verbose_name, name, **kwargs)
def _check_fix_default_value(self):
"""
Adds a warning to the checks framework stating, that using an actual
date or datetime value is probably wrong; it's only being evaluated on
server start-up.
For details see ticket #21905
"""
if not self.has_default():
return []
now = timezone.now()
if not timezone.is_naive(now):
now = timezone.make_naive(now, timezone.utc)
value = self.default
if isinstance(value, datetime.datetime):
if not timezone.is_naive(value):
value = timezone.make_naive(value, timezone.utc)
value = value.date()
elif isinstance(value, datetime.date):
# Nothing to do, as dates don't have tz information
pass
else:
# No explicit date / datetime value -- no checks necessary
return []
offset = datetime.timedelta(days=1)
lower = (now - offset).date()
upper = (now + offset).date()
if lower <= value <= upper:
return [
checks.Warning(
'Fixed default value provided.',
hint='It seems you set a fixed date / time / datetime '
'value as default for this field. This may not be '
'what you want. If you want to have the current date '
'as default, use `django.utils.timezone.now`',
obj=self,
id='fields.W161',
)
]
return []
def deconstruct(self):
name, path, args, kwargs = super(DateField, self).deconstruct()
if self.auto_now:
kwargs['auto_now'] = True
if self.auto_now_add:
kwargs['auto_now_add'] = True
if self.auto_now or self.auto_now_add:
del kwargs['editable']
del kwargs['blank']
return name, path, args, kwargs
def get_internal_type(self):
return "DateField"
def to_python(self, value):
if value is None:
return value
if isinstance(value, datetime.datetime):
if settings.USE_TZ and timezone.is_aware(value):
# Convert aware datetimes to the default time zone
# before casting them to dates (#17742).
default_timezone = timezone.get_default_timezone()
value = timezone.make_naive(value, default_timezone)
return value.date()
if isinstance(value, datetime.date):
return value
try:
parsed = parse_date(value)
if parsed is not None:
return parsed
except ValueError:
raise exceptions.ValidationError(
self.error_messages['invalid_date'],
code='invalid_date',
params={'value': value},
)
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def pre_save(self, model_instance, add):
if self.auto_now or (self.auto_now_add and add):
value = datetime.date.today()
setattr(model_instance, self.attname, value)
return value
else:
return super(DateField, self).pre_save(model_instance, add)
def contribute_to_class(self, cls, name, **kwargs):
super(DateField, self).contribute_to_class(cls, name, **kwargs)
if not self.null:
setattr(cls, 'get_next_by_%s' % self.name,
curry(cls._get_next_or_previous_by_FIELD, field=self,
is_next=True))
setattr(cls, 'get_previous_by_%s' % self.name,
curry(cls._get_next_or_previous_by_FIELD, field=self,
is_next=False))
def get_prep_value(self, value):
value = super(DateField, self).get_prep_value(value)
return self.to_python(value)
def get_db_prep_value(self, value, connection, prepared=False):
# Casts dates into the format expected by the backend
if not prepared:
value = self.get_prep_value(value)
return connection.ops.adapt_datefield_value(value)
def value_to_string(self, obj):
val = self.value_from_object(obj)
return '' if val is None else val.isoformat()
def formfield(self, **kwargs):
defaults = {'form_class': forms.DateField}
defaults.update(kwargs)
return super(DateField, self).formfield(**defaults)
class DateTimeField(DateField):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value has an invalid format. It must be in "
"YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format."),
'invalid_date': _("'%(value)s' value has the correct format "
"(YYYY-MM-DD) but it is an invalid date."),
'invalid_datetime': _("'%(value)s' value has the correct format "
"(YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]) "
"but it is an invalid date/time."),
}
description = _("Date (with time)")
# __init__ is inherited from DateField
def _check_fix_default_value(self):
"""
Adds a warning to the checks framework stating, that using an actual
date or datetime value is probably wrong; it's only being evaluated on
server start-up.
For details see ticket #21905
"""
if not self.has_default():
return []
now = timezone.now()
if not timezone.is_naive(now):
now = timezone.make_naive(now, timezone.utc)
value = self.default
if isinstance(value, datetime.datetime):
second_offset = datetime.timedelta(seconds=10)
lower = now - second_offset
upper = now + second_offset
if timezone.is_aware(value):
value = timezone.make_naive(value, timezone.utc)
elif isinstance(value, datetime.date):
second_offset = datetime.timedelta(seconds=10)
lower = now - second_offset
lower = datetime.datetime(lower.year, lower.month, lower.day)
upper = now + second_offset
upper = datetime.datetime(upper.year, upper.month, upper.day)
value = datetime.datetime(value.year, value.month, value.day)
else:
# No explicit date / datetime value -- no checks necessary
return []
if lower <= value <= upper:
return [
checks.Warning(
'Fixed default value provided.',
hint='It seems you set a fixed date / time / datetime '
'value as default for this field. This may not be '
'what you want. If you want to have the current date '
'as default, use `django.utils.timezone.now`',
obj=self,
id='fields.W161',
)
]
return []
def get_internal_type(self):
return "DateTimeField"
def to_python(self, value):
if value is None:
return value
if isinstance(value, datetime.datetime):
return value
if isinstance(value, datetime.date):
value = datetime.datetime(value.year, value.month, value.day)
if settings.USE_TZ:
# For backwards compatibility, interpret naive datetimes in
# local time. This won't work during DST change, but we can't
# do much about it, so we let the exceptions percolate up the
# call stack.
warnings.warn("DateTimeField %s.%s received a naive datetime "
"(%s) while time zone support is active." %
(self.model.__name__, self.name, value),
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
value = timezone.make_aware(value, default_timezone)
return value
try:
parsed = parse_datetime(value)
if parsed is not None:
return parsed
except ValueError:
raise exceptions.ValidationError(
self.error_messages['invalid_datetime'],
code='invalid_datetime',
params={'value': value},
)
try:
parsed = parse_date(value)
if parsed is not None:
return datetime.datetime(parsed.year, parsed.month, parsed.day)
except ValueError:
raise exceptions.ValidationError(
self.error_messages['invalid_date'],
code='invalid_date',
params={'value': value},
)
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def pre_save(self, model_instance, add):
if self.auto_now or (self.auto_now_add and add):
value = timezone.now()
setattr(model_instance, self.attname, value)
return value
else:
return super(DateTimeField, self).pre_save(model_instance, add)
# contribute_to_class is inherited from DateField, it registers
# get_next_by_FOO and get_prev_by_FOO
# get_prep_lookup is inherited from DateField
def get_prep_value(self, value):
value = super(DateTimeField, self).get_prep_value(value)
value = self.to_python(value)
if value is not None and settings.USE_TZ and timezone.is_naive(value):
# For backwards compatibility, interpret naive datetimes in local
# time. This won't work during DST change, but we can't do much
# about it, so we let the exceptions percolate up the call stack.
try:
name = '%s.%s' % (self.model.__name__, self.name)
except AttributeError:
name = '(unbound)'
warnings.warn("DateTimeField %s received a naive datetime (%s)"
" while time zone support is active." %
(name, value),
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
value = timezone.make_aware(value, default_timezone)
return value
def get_db_prep_value(self, value, connection, prepared=False):
# Casts datetimes into the format expected by the backend
if not prepared:
value = self.get_prep_value(value)
return connection.ops.adapt_datetimefield_value(value)
def value_to_string(self, obj):
val = self.value_from_object(obj)
return '' if val is None else val.isoformat()
def formfield(self, **kwargs):
defaults = {'form_class': forms.DateTimeField}
defaults.update(kwargs)
return super(DateTimeField, self).formfield(**defaults)
class DecimalField(Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value must be a decimal number."),
}
description = _("Decimal number")
def __init__(self, verbose_name=None, name=None, max_digits=None,
decimal_places=None, **kwargs):
self.max_digits, self.decimal_places = max_digits, decimal_places
super(DecimalField, self).__init__(verbose_name, name, **kwargs)
def check(self, **kwargs):
errors = super(DecimalField, self).check(**kwargs)
digits_errors = self._check_decimal_places()
digits_errors.extend(self._check_max_digits())
if not digits_errors:
errors.extend(self._check_decimal_places_and_max_digits(**kwargs))
else:
errors.extend(digits_errors)
return errors
def _check_decimal_places(self):
try:
decimal_places = int(self.decimal_places)
if decimal_places < 0:
raise ValueError()
except TypeError:
return [
checks.Error(
"DecimalFields must define a 'decimal_places' attribute.",
hint=None,
obj=self,
id='fields.E130',
)
]
except ValueError:
return [
checks.Error(
"'decimal_places' must be a non-negative integer.",
hint=None,
obj=self,
id='fields.E131',
)
]
else:
return []
def _check_max_digits(self):
try:
max_digits = int(self.max_digits)
if max_digits <= 0:
raise ValueError()
except TypeError:
return [
checks.Error(
"DecimalFields must define a 'max_digits' attribute.",
hint=None,
obj=self,
id='fields.E132',
)
]
except ValueError:
return [
checks.Error(
"'max_digits' must be a positive integer.",
hint=None,
obj=self,
id='fields.E133',
)
]
else:
return []
def _check_decimal_places_and_max_digits(self, **kwargs):
if int(self.decimal_places) > int(self.max_digits):
return [
checks.Error(
"'max_digits' must be greater or equal to 'decimal_places'.",
hint=None,
obj=self,
id='fields.E134',
)
]
return []
@cached_property
def validators(self):
return super(DecimalField, self).validators + [
validators.DecimalValidator(self.max_digits, self.decimal_places)
]
def deconstruct(self):
name, path, args, kwargs = super(DecimalField, self).deconstruct()
if self.max_digits is not None:
kwargs['max_digits'] = self.max_digits
if self.decimal_places is not None:
kwargs['decimal_places'] = self.decimal_places
return name, path, args, kwargs
def get_internal_type(self):
return "DecimalField"
def to_python(self, value):
if value is None:
return value
try:
return decimal.Decimal(value)
except decimal.InvalidOperation:
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def _format(self, value):
if isinstance(value, six.string_types):
return value
else:
return self.format_number(value)
def format_number(self, value):
"""
Formats a number into a string with the requisite number of digits and
decimal places.
"""
# Method moved to django.db.backends.utils.
#
# It is preserved because it is used by the oracle backend
# (django.db.backends.oracle.query), and also for
# backwards-compatibility with any external code which may have used
# this method.
from django.db.backends import utils
return utils.format_number(value, self.max_digits, self.decimal_places)
def get_db_prep_save(self, value, connection):
return connection.ops.adapt_decimalfield_value(self.to_python(value),
self.max_digits, self.decimal_places)
def get_prep_value(self, value):
value = super(DecimalField, self).get_prep_value(value)
return self.to_python(value)
def formfield(self, **kwargs):
defaults = {
'max_digits': self.max_digits,
'decimal_places': self.decimal_places,
'form_class': forms.DecimalField,
}
defaults.update(kwargs)
return super(DecimalField, self).formfield(**defaults)
class DurationField(Field):
"""Stores timedelta objects.
Uses interval on postgres, INVERAL DAY TO SECOND on Oracle, and bigint of
microseconds on other databases.
"""
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value has an invalid format. It must be in "
"[DD] [HH:[MM:]]ss[.uuuuuu] format.")
}
description = _("Duration")
def get_internal_type(self):
return "DurationField"
def to_python(self, value):
if value is None:
return value
if isinstance(value, datetime.timedelta):
return value
try:
parsed = parse_duration(value)
except ValueError:
pass
else:
if parsed is not None:
return parsed
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def get_db_prep_value(self, value, connection, prepared=False):
if connection.features.has_native_duration_field:
return value
if value is None:
return None
return value.total_seconds() * 1000000
def get_db_converters(self, connection):
converters = []
if not connection.features.has_native_duration_field:
converters.append(connection.ops.convert_durationfield_value)
return converters + super(DurationField, self).get_db_converters(connection)
def value_to_string(self, obj):
val = self.value_from_object(obj)
return '' if val is None else duration_string(val)
def formfield(self, **kwargs):
defaults = {
'form_class': forms.DurationField,
}
defaults.update(kwargs)
return super(DurationField, self).formfield(**defaults)
class EmailField(CharField):
default_validators = [validators.validate_email]
description = _("Email address")
def __init__(self, *args, **kwargs):
# max_length=254 to be compliant with RFCs 3696 and 5321
kwargs['max_length'] = kwargs.get('max_length', 254)
super(EmailField, self).__init__(*args, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super(EmailField, self).deconstruct()
# We do not exclude max_length if it matches default as we want to change
# the default in future.
return name, path, args, kwargs
def formfield(self, **kwargs):
# As with CharField, this will cause email validation to be performed
# twice.
defaults = {
'form_class': forms.EmailField,
}
defaults.update(kwargs)
return super(EmailField, self).formfield(**defaults)
class FilePathField(Field):
description = _("File path")
def __init__(self, verbose_name=None, name=None, path='', match=None,
recursive=False, allow_files=True, allow_folders=False, **kwargs):
self.path, self.match, self.recursive = path, match, recursive
self.allow_files, self.allow_folders = allow_files, allow_folders
kwargs['max_length'] = kwargs.get('max_length', 100)
super(FilePathField, self).__init__(verbose_name, name, **kwargs)
def check(self, **kwargs):
errors = super(FilePathField, self).check(**kwargs)
errors.extend(self._check_allowing_files_or_folders(**kwargs))
return errors
def _check_allowing_files_or_folders(self, **kwargs):
if not self.allow_files and not self.allow_folders:
return [
checks.Error(
"FilePathFields must have either 'allow_files' or 'allow_folders' set to True.",
hint=None,
obj=self,
id='fields.E140',
)
]
return []
def deconstruct(self):
name, path, args, kwargs = super(FilePathField, self).deconstruct()
if self.path != '':
kwargs['path'] = self.path
if self.match is not None:
kwargs['match'] = self.match
if self.recursive is not False:
kwargs['recursive'] = self.recursive
if self.allow_files is not True:
kwargs['allow_files'] = self.allow_files
if self.allow_folders is not False:
kwargs['allow_folders'] = self.allow_folders
if kwargs.get("max_length") == 100:
del kwargs["max_length"]
return name, path, args, kwargs
def get_prep_value(self, value):
value = super(FilePathField, self).get_prep_value(value)
if value is None:
return None
return six.text_type(value)
def formfield(self, **kwargs):
defaults = {
'path': self.path,
'match': self.match,
'recursive': self.recursive,
'form_class': forms.FilePathField,
'allow_files': self.allow_files,
'allow_folders': self.allow_folders,
}
defaults.update(kwargs)
return super(FilePathField, self).formfield(**defaults)
def get_internal_type(self):
return "FilePathField"
class FloatField(Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value must be a float."),
}
description = _("Floating point number")
def get_prep_value(self, value):
value = super(FloatField, self).get_prep_value(value)
if value is None:
return None
return float(value)
def get_internal_type(self):
return "FloatField"
def to_python(self, value):
if value is None:
return value
try:
return float(value)
except (TypeError, ValueError):
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def formfield(self, **kwargs):
defaults = {'form_class': forms.FloatField}
defaults.update(kwargs)
return super(FloatField, self).formfield(**defaults)
class IntegerField(Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value must be an integer."),
}
description = _("Integer")
def check(self, **kwargs):
errors = super(IntegerField, self).check(**kwargs)
errors.extend(self._check_max_length_warning())
return errors
def _check_max_length_warning(self):
if self.max_length is not None:
return [
checks.Warning(
"'max_length' is ignored when used with IntegerField",
hint="Remove 'max_length' from field",
obj=self,
id='fields.W122',
)
]
return []
@cached_property
def validators(self):
# These validators can't be added at field initialization time since
# they're based on values retrieved from `connection`.
range_validators = []
internal_type = self.get_internal_type()
min_value, max_value = connection.ops.integer_field_range(internal_type)
if min_value is not None:
range_validators.append(validators.MinValueValidator(min_value))
if max_value is not None:
range_validators.append(validators.MaxValueValidator(max_value))
return super(IntegerField, self).validators + range_validators
def get_prep_value(self, value):
value = super(IntegerField, self).get_prep_value(value)
if value is None:
return None
return int(value)
def get_prep_lookup(self, lookup_type, value):
if ((lookup_type == 'gte' or lookup_type == 'lt')
and isinstance(value, float)):
value = math.ceil(value)
return super(IntegerField, self).get_prep_lookup(lookup_type, value)
def get_internal_type(self):
return "IntegerField"
def to_python(self, value):
if value is None:
return value
try:
return int(value)
except (TypeError, ValueError):
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def formfield(self, **kwargs):
defaults = {'form_class': forms.IntegerField}
defaults.update(kwargs)
return super(IntegerField, self).formfield(**defaults)
class BigIntegerField(IntegerField):
empty_strings_allowed = False
description = _("Big (8 byte) integer")
MAX_BIGINT = 9223372036854775807
def get_internal_type(self):
return "BigIntegerField"
def formfield(self, **kwargs):
defaults = {'min_value': -BigIntegerField.MAX_BIGINT - 1,
'max_value': BigIntegerField.MAX_BIGINT}
defaults.update(kwargs)
return super(BigIntegerField, self).formfield(**defaults)
class IPAddressField(Field):
empty_strings_allowed = False
description = _("IPv4 address")
system_check_removed_details = {
'msg': (
'IPAddressField has been removed except for support in '
'historical migrations.'
),
'hint': 'Use GenericIPAddressField instead.',
'id': 'fields.E900',
}
def __init__(self, *args, **kwargs):
kwargs['max_length'] = 15
super(IPAddressField, self).__init__(*args, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super(IPAddressField, self).deconstruct()
del kwargs['max_length']
return name, path, args, kwargs
def get_prep_value(self, value):
value = super(IPAddressField, self).get_prep_value(value)
if value is None:
return None
return six.text_type(value)
def get_internal_type(self):
return "IPAddressField"
class GenericIPAddressField(Field):
empty_strings_allowed = False
description = _("IP address")
default_error_messages = {}
def __init__(self, verbose_name=None, name=None, protocol='both',
unpack_ipv4=False, *args, **kwargs):
self.unpack_ipv4 = unpack_ipv4
self.protocol = protocol
self.default_validators, invalid_error_message = \
validators.ip_address_validators(protocol, unpack_ipv4)
self.default_error_messages['invalid'] = invalid_error_message
kwargs['max_length'] = 39
super(GenericIPAddressField, self).__init__(verbose_name, name, *args,
**kwargs)
def check(self, **kwargs):
errors = super(GenericIPAddressField, self).check(**kwargs)
errors.extend(self._check_blank_and_null_values(**kwargs))
return errors
def _check_blank_and_null_values(self, **kwargs):
if not getattr(self, 'null', False) and getattr(self, 'blank', False):
return [
checks.Error(
('GenericIPAddressFields cannot have blank=True if null=False, '
'as blank values are stored as nulls.'),
hint=None,
obj=self,
id='fields.E150',
)
]
return []
def deconstruct(self):
name, path, args, kwargs = super(GenericIPAddressField, self).deconstruct()
if self.unpack_ipv4 is not False:
kwargs['unpack_ipv4'] = self.unpack_ipv4
if self.protocol != "both":
kwargs['protocol'] = self.protocol
if kwargs.get("max_length") == 39:
del kwargs['max_length']
return name, path, args, kwargs
def get_internal_type(self):
return "GenericIPAddressField"
def to_python(self, value):
if value is None:
return None
if not isinstance(value, six.string_types):
value = force_text(value)
value = value.strip()
if ':' in value:
return clean_ipv6_address(value,
self.unpack_ipv4, self.error_messages['invalid'])
return value
def get_db_prep_value(self, value, connection, prepared=False):
if not prepared:
value = self.get_prep_value(value)
return connection.ops.adapt_ipaddressfield_value(value)
def get_prep_value(self, value):
value = super(GenericIPAddressField, self).get_prep_value(value)
if value is None:
return None
if value and ':' in value:
try:
return clean_ipv6_address(value, self.unpack_ipv4)
except exceptions.ValidationError:
pass
return six.text_type(value)
def formfield(self, **kwargs):
defaults = {
'protocol': self.protocol,
'form_class': forms.GenericIPAddressField,
}
defaults.update(kwargs)
return super(GenericIPAddressField, self).formfield(**defaults)
class NullBooleanField(Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value must be either None, True or False."),
}
description = _("Boolean (Either True, False or None)")
def __init__(self, *args, **kwargs):
kwargs['null'] = True
kwargs['blank'] = True
super(NullBooleanField, self).__init__(*args, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super(NullBooleanField, self).deconstruct()
del kwargs['null']
del kwargs['blank']
return name, path, args, kwargs
def get_internal_type(self):
return "NullBooleanField"
def to_python(self, value):
if value is None:
return None
if value in (True, False):
return bool(value)
if value in ('None',):
return None
if value in ('t', 'True', '1'):
return True
if value in ('f', 'False', '0'):
return False
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def get_prep_lookup(self, lookup_type, value):
# Special-case handling for filters coming from a Web request (e.g. the
# admin interface). Only works for scalar values (not lists). If you're
# passing in a list, you might as well make things the right type when
# constructing the list.
if value in ('1', '0'):
value = bool(int(value))
return super(NullBooleanField, self).get_prep_lookup(lookup_type,
value)
def get_prep_value(self, value):
value = super(NullBooleanField, self).get_prep_value(value)
if value is None:
return None
return bool(value)
def formfield(self, **kwargs):
defaults = {
'form_class': forms.NullBooleanField,
'required': not self.blank,
'label': capfirst(self.verbose_name),
'help_text': self.help_text}
defaults.update(kwargs)
return super(NullBooleanField, self).formfield(**defaults)
class PositiveIntegerField(IntegerField):
description = _("Positive integer")
def get_internal_type(self):
return "PositiveIntegerField"
def formfield(self, **kwargs):
defaults = {'min_value': 0}
defaults.update(kwargs)
return super(PositiveIntegerField, self).formfield(**defaults)
class PositiveSmallIntegerField(IntegerField):
description = _("Positive small integer")
def get_internal_type(self):
return "PositiveSmallIntegerField"
def formfield(self, **kwargs):
defaults = {'min_value': 0}
defaults.update(kwargs)
return super(PositiveSmallIntegerField, self).formfield(**defaults)
class SlugField(CharField):
default_validators = [validators.validate_slug]
description = _("Slug (up to %(max_length)s)")
def __init__(self, *args, **kwargs):
kwargs['max_length'] = kwargs.get('max_length', 50)
# Set db_index=True unless it's been set manually.
if 'db_index' not in kwargs:
kwargs['db_index'] = True
self.allow_unicode = kwargs.pop('allow_unicode', False)
if self.allow_unicode:
self.default_validators = [validators.validate_unicode_slug]
super(SlugField, self).__init__(*args, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super(SlugField, self).deconstruct()
if kwargs.get("max_length") == 50:
del kwargs['max_length']
if self.db_index is False:
kwargs['db_index'] = False
else:
del kwargs['db_index']
if self.allow_unicode is not False:
kwargs['allow_unicode'] = self.allow_unicode
return name, path, args, kwargs
def get_internal_type(self):
return "SlugField"
def formfield(self, **kwargs):
defaults = {'form_class': forms.SlugField, 'allow_unicode': self.allow_unicode}
defaults.update(kwargs)
return super(SlugField, self).formfield(**defaults)
class SmallIntegerField(IntegerField):
description = _("Small integer")
def get_internal_type(self):
return "SmallIntegerField"
class TextField(Field):
description = _("Text")
def get_internal_type(self):
return "TextField"
def to_python(self, value):
if isinstance(value, six.string_types) or value is None:
return value
return smart_text(value)
def get_prep_value(self, value):
value = super(TextField, self).get_prep_value(value)
return self.to_python(value)
def formfield(self, **kwargs):
# Passing max_length to forms.CharField means that the value's length
# will be validated twice. This is considered acceptable since we want
# the value in the form field (to pass into widget for example).
defaults = {'max_length': self.max_length, 'widget': forms.Textarea}
defaults.update(kwargs)
return super(TextField, self).formfield(**defaults)
class TimeField(DateTimeCheckMixin, Field):
empty_strings_allowed = False
default_error_messages = {
'invalid': _("'%(value)s' value has an invalid format. It must be in "
"HH:MM[:ss[.uuuuuu]] format."),
'invalid_time': _("'%(value)s' value has the correct format "
"(HH:MM[:ss[.uuuuuu]]) but it is an invalid time."),
}
description = _("Time")
def __init__(self, verbose_name=None, name=None, auto_now=False,
auto_now_add=False, **kwargs):
self.auto_now, self.auto_now_add = auto_now, auto_now_add
if auto_now or auto_now_add:
kwargs['editable'] = False
kwargs['blank'] = True
super(TimeField, self).__init__(verbose_name, name, **kwargs)
def _check_fix_default_value(self):
"""
Adds a warning to the checks framework stating, that using an actual
time or datetime value is probably wrong; it's only being evaluated on
server start-up.
For details see ticket #21905
"""
if not self.has_default():
return []
now = timezone.now()
if not timezone.is_naive(now):
now = timezone.make_naive(now, timezone.utc)
value = self.default
if isinstance(value, datetime.datetime):
second_offset = datetime.timedelta(seconds=10)
lower = now - second_offset
upper = now + second_offset
if timezone.is_aware(value):
value = timezone.make_naive(value, timezone.utc)
elif isinstance(value, datetime.time):
second_offset = datetime.timedelta(seconds=10)
lower = now - second_offset
upper = now + second_offset
value = datetime.datetime.combine(now.date(), value)
if timezone.is_aware(value):
value = timezone.make_naive(value, timezone.utc).time()
else:
# No explicit time / datetime value -- no checks necessary
return []
if lower <= value <= upper:
return [
checks.Warning(
'Fixed default value provided.',
hint='It seems you set a fixed date / time / datetime '
'value as default for this field. This may not be '
'what you want. If you want to have the current date '
'as default, use `django.utils.timezone.now`',
obj=self,
id='fields.W161',
)
]
return []
def deconstruct(self):
name, path, args, kwargs = super(TimeField, self).deconstruct()
if self.auto_now is not False:
kwargs["auto_now"] = self.auto_now
if self.auto_now_add is not False:
kwargs["auto_now_add"] = self.auto_now_add
if self.auto_now or self.auto_now_add:
del kwargs['blank']
del kwargs['editable']
return name, path, args, kwargs
def get_internal_type(self):
return "TimeField"
def to_python(self, value):
if value is None:
return None
if isinstance(value, datetime.time):
return value
if isinstance(value, datetime.datetime):
# Not usually a good idea to pass in a datetime here (it loses
# information), but this can be a side-effect of interacting with a
# database backend (e.g. Oracle), so we'll be accommodating.
return value.time()
try:
parsed = parse_time(value)
if parsed is not None:
return parsed
except ValueError:
raise exceptions.ValidationError(
self.error_messages['invalid_time'],
code='invalid_time',
params={'value': value},
)
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
def pre_save(self, model_instance, add):
if self.auto_now or (self.auto_now_add and add):
value = datetime.datetime.now().time()
setattr(model_instance, self.attname, value)
return value
else:
return super(TimeField, self).pre_save(model_instance, add)
def get_prep_value(self, value):
value = super(TimeField, self).get_prep_value(value)
return self.to_python(value)
def get_db_prep_value(self, value, connection, prepared=False):
# Casts times into the format expected by the backend
if not prepared:
value = self.get_prep_value(value)
return connection.ops.adapt_timefield_value(value)
def value_to_string(self, obj):
val = self.value_from_object(obj)
return '' if val is None else val.isoformat()
def formfield(self, **kwargs):
defaults = {'form_class': forms.TimeField}
defaults.update(kwargs)
return super(TimeField, self).formfield(**defaults)
class URLField(CharField):
default_validators = [validators.URLValidator()]
description = _("URL")
def __init__(self, verbose_name=None, name=None, **kwargs):
kwargs['max_length'] = kwargs.get('max_length', 200)
super(URLField, self).__init__(verbose_name, name, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super(URLField, self).deconstruct()
if kwargs.get("max_length") == 200:
del kwargs['max_length']
return name, path, args, kwargs
def formfield(self, **kwargs):
# As with CharField, this will cause URL validation to be performed
# twice.
defaults = {
'form_class': forms.URLField,
}
defaults.update(kwargs)
return super(URLField, self).formfield(**defaults)
class BinaryField(Field):
description = _("Raw binary data")
empty_values = [None, b'']
def __init__(self, *args, **kwargs):
kwargs['editable'] = False
super(BinaryField, self).__init__(*args, **kwargs)
if self.max_length is not None:
self.validators.append(validators.MaxLengthValidator(self.max_length))
def deconstruct(self):
name, path, args, kwargs = super(BinaryField, self).deconstruct()
del kwargs['editable']
return name, path, args, kwargs
def get_internal_type(self):
return "BinaryField"
def get_default(self):
if self.has_default() and not callable(self.default):
return self.default
default = super(BinaryField, self).get_default()
if default == '':
return b''
return default
def get_db_prep_value(self, value, connection, prepared=False):
value = super(BinaryField, self).get_db_prep_value(value, connection, prepared)
if value is not None:
return connection.Database.Binary(value)
return value
def value_to_string(self, obj):
"""Binary data is serialized as base64"""
return b64encode(force_bytes(self.value_from_object(obj))).decode('ascii')
def to_python(self, value):
# If it's a string, it should be base64-encoded data
if isinstance(value, six.text_type):
return six.memoryview(b64decode(force_bytes(value)))
return value
class UUIDField(Field):
default_error_messages = {
'invalid': _("'%(value)s' is not a valid UUID."),
}
description = 'Universally unique identifier'
empty_strings_allowed = False
def __init__(self, verbose_name=None, **kwargs):
kwargs['max_length'] = 32
super(UUIDField, self).__init__(verbose_name, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super(UUIDField, self).deconstruct()
del kwargs['max_length']
return name, path, args, kwargs
def get_internal_type(self):
return "UUIDField"
def get_db_prep_value(self, value, connection, prepared=False):
if value is None:
return None
if not isinstance(value, uuid.UUID):
try:
value = uuid.UUID(value)
except AttributeError:
raise TypeError(self.error_messages['invalid'] % {'value': value})
if connection.features.has_native_uuid_field:
return value
return value.hex
def to_python(self, value):
if value and not isinstance(value, uuid.UUID):
try:
return uuid.UUID(value)
except ValueError:
raise exceptions.ValidationError(
self.error_messages['invalid'],
code='invalid',
params={'value': value},
)
return value
def formfield(self, **kwargs):
defaults = {
'form_class': forms.UUIDField,
}
defaults.update(kwargs)
return super(UUIDField, self).formfield(**defaults)
| gpl-3.0 |
anarchivist/dial-a-dpla | dial_a_dpla/app.py | 1 | 1902 | import re
from flask import Flask
from flask import render_template
from flask import url_for
from flask import request
import urllib
from twilio import twiml
from requests import get as rget
from requests.compat import urlencode
import os
import random
api_key = os.environ.get('DPLA_API_KEY', None)
# Declare and configure application
app = Flask(__name__, static_url_path='/static')
app.config.from_pyfile('local_settings.py')
@app.route('/')
def hello():
r = twiml.Response()
r.say("Welcome to Dial a D P L A!")
r.say("Today we are providing access to Kentucky Digital Library's Claude Sullivan audio recordings.")
with r.gather(numDigits=4, action="lookup", method="POST") as g:
g.say("Please enter a four digit year of recording followed by the pound key.")
return str(r)
@app.route('/lookup', methods=['POST'])
def obj():
year = request.values.get('Digits', None)
r = twiml.Response()
params = {
"sourceResource.type": "sound",
"provider.name": "Kentucky Digital Library",
"sourceResource.date.begin": str(year),
"api_key": api_key,
"page_size": 100
}
url = "http://api.dp.la/v2/items/?%s" % urllib.urlencode(params)
results = rget(url).json()
if len(results['docs']) < 1:
r.say("Sorry, nothing matched your query.")
else:
if results['count'] > params['page_size']:
upper_bound = params['page_size'] - 1
else:
upper_bound = results['count'] - 1
index = random.randint(0, upper_bound)
item = results['docs'][index]
stream = item['object']
stream = stream.replace("_tb.mp3", ".mp3")
phrase = "You are about to listen to: " + item['sourceResource']['title'] + ". "
phrase += "This item is from " + item['dataProvider'] + "."
r.say(phrase)
r.play(stream)
return str(r)
| mit |
AutorestCI/azure-sdk-for-python | azure-mgmt-network/azure/mgmt/network/v2017_10_01/models/virtual_network_gateway_connection_list_entity.py | 1 | 7717 | # coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from .resource import Resource
class VirtualNetworkGatewayConnectionListEntity(Resource):
"""A common class for general resource information.
Variables are only populated by the server, and will be ignored when
sending a request.
:param id: Resource ID.
:type id: str
:ivar name: Resource name.
:vartype name: str
:ivar type: Resource type.
:vartype type: str
:param location: Resource location.
:type location: str
:param tags: Resource tags.
:type tags: dict[str, str]
:param authorization_key: The authorizationKey.
:type authorization_key: str
:param virtual_network_gateway1: The reference to virtual network gateway
resource.
:type virtual_network_gateway1:
~azure.mgmt.network.v2017_10_01.models.VirtualNetworkConnectionGatewayReference
:param virtual_network_gateway2: The reference to virtual network gateway
resource.
:type virtual_network_gateway2:
~azure.mgmt.network.v2017_10_01.models.VirtualNetworkConnectionGatewayReference
:param local_network_gateway2: The reference to local network gateway
resource.
:type local_network_gateway2:
~azure.mgmt.network.v2017_10_01.models.VirtualNetworkConnectionGatewayReference
:param connection_type: Gateway connection type. Possible values are:
'Ipsec','Vnet2Vnet','ExpressRoute', and 'VPNClient. Possible values
include: 'IPsec', 'Vnet2Vnet', 'ExpressRoute', 'VPNClient'
:type connection_type: str or
~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayConnectionType
:param routing_weight: The routing weight.
:type routing_weight: int
:param shared_key: The IPSec shared key.
:type shared_key: str
:ivar connection_status: Virtual network Gateway connection status.
Possible values are 'Unknown', 'Connecting', 'Connected' and
'NotConnected'. Possible values include: 'Unknown', 'Connecting',
'Connected', 'NotConnected'
:vartype connection_status: str or
~azure.mgmt.network.v2017_10_01.models.VirtualNetworkGatewayConnectionStatus
:ivar tunnel_connection_status: Collection of all tunnels' connection
health status.
:vartype tunnel_connection_status:
list[~azure.mgmt.network.v2017_10_01.models.TunnelConnectionHealth]
:ivar egress_bytes_transferred: The egress bytes transferred in this
connection.
:vartype egress_bytes_transferred: long
:ivar ingress_bytes_transferred: The ingress bytes transferred in this
connection.
:vartype ingress_bytes_transferred: long
:param peer: The reference to peerings resource.
:type peer: ~azure.mgmt.network.v2017_10_01.models.SubResource
:param enable_bgp: EnableBgp flag
:type enable_bgp: bool
:param use_policy_based_traffic_selectors: Enable policy-based traffic
selectors.
:type use_policy_based_traffic_selectors: bool
:param ipsec_policies: The IPSec Policies to be considered by this
connection.
:type ipsec_policies:
list[~azure.mgmt.network.v2017_10_01.models.IpsecPolicy]
:param resource_guid: The resource GUID property of the
VirtualNetworkGatewayConnection resource.
:type resource_guid: str
:ivar provisioning_state: The provisioning state of the
VirtualNetworkGatewayConnection resource. Possible values are: 'Updating',
'Deleting', and 'Failed'.
:vartype provisioning_state: str
:param etag: Gets a unique read-only string that changes whenever the
resource is updated.
:type etag: str
"""
_validation = {
'name': {'readonly': True},
'type': {'readonly': True},
'virtual_network_gateway1': {'required': True},
'connection_type': {'required': True},
'connection_status': {'readonly': True},
'tunnel_connection_status': {'readonly': True},
'egress_bytes_transferred': {'readonly': True},
'ingress_bytes_transferred': {'readonly': True},
'provisioning_state': {'readonly': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type': {'key': 'type', 'type': 'str'},
'location': {'key': 'location', 'type': 'str'},
'tags': {'key': 'tags', 'type': '{str}'},
'authorization_key': {'key': 'properties.authorizationKey', 'type': 'str'},
'virtual_network_gateway1': {'key': 'properties.virtualNetworkGateway1', 'type': 'VirtualNetworkConnectionGatewayReference'},
'virtual_network_gateway2': {'key': 'properties.virtualNetworkGateway2', 'type': 'VirtualNetworkConnectionGatewayReference'},
'local_network_gateway2': {'key': 'properties.localNetworkGateway2', 'type': 'VirtualNetworkConnectionGatewayReference'},
'connection_type': {'key': 'properties.connectionType', 'type': 'str'},
'routing_weight': {'key': 'properties.routingWeight', 'type': 'int'},
'shared_key': {'key': 'properties.sharedKey', 'type': 'str'},
'connection_status': {'key': 'properties.connectionStatus', 'type': 'str'},
'tunnel_connection_status': {'key': 'properties.tunnelConnectionStatus', 'type': '[TunnelConnectionHealth]'},
'egress_bytes_transferred': {'key': 'properties.egressBytesTransferred', 'type': 'long'},
'ingress_bytes_transferred': {'key': 'properties.ingressBytesTransferred', 'type': 'long'},
'peer': {'key': 'properties.peer', 'type': 'SubResource'},
'enable_bgp': {'key': 'properties.enableBgp', 'type': 'bool'},
'use_policy_based_traffic_selectors': {'key': 'properties.usePolicyBasedTrafficSelectors', 'type': 'bool'},
'ipsec_policies': {'key': 'properties.ipsecPolicies', 'type': '[IpsecPolicy]'},
'resource_guid': {'key': 'properties.resourceGuid', 'type': 'str'},
'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
'etag': {'key': 'etag', 'type': 'str'},
}
def __init__(self, virtual_network_gateway1, connection_type, id=None, location=None, tags=None, authorization_key=None, virtual_network_gateway2=None, local_network_gateway2=None, routing_weight=None, shared_key=None, peer=None, enable_bgp=None, use_policy_based_traffic_selectors=None, ipsec_policies=None, resource_guid=None, etag=None):
super(VirtualNetworkGatewayConnectionListEntity, self).__init__(id=id, location=location, tags=tags)
self.authorization_key = authorization_key
self.virtual_network_gateway1 = virtual_network_gateway1
self.virtual_network_gateway2 = virtual_network_gateway2
self.local_network_gateway2 = local_network_gateway2
self.connection_type = connection_type
self.routing_weight = routing_weight
self.shared_key = shared_key
self.connection_status = None
self.tunnel_connection_status = None
self.egress_bytes_transferred = None
self.ingress_bytes_transferred = None
self.peer = peer
self.enable_bgp = enable_bgp
self.use_policy_based_traffic_selectors = use_policy_based_traffic_selectors
self.ipsec_policies = ipsec_policies
self.resource_guid = resource_guid
self.provisioning_state = None
self.etag = etag
| mit |
WebSpider/SickRage | lib/babelfish/converters/opensubtitles.py | 80 | 1727 | # -*- coding: utf-8 -*-
#
# Copyright (c) 2013 the BabelFish authors. All rights reserved.
# Use of this source code is governed by the 3-clause BSD license
# that can be found in the LICENSE file.
#
from __future__ import unicode_literals
from . import LanguageReverseConverter, CaseInsensitiveDict
from ..exceptions import LanguageReverseError
from ..language import language_converters
class OpenSubtitlesConverter(LanguageReverseConverter):
def __init__(self):
self.alpha3b_converter = language_converters['alpha3b']
self.alpha2_converter = language_converters['alpha2']
self.to_opensubtitles = {('por', 'BR'): 'pob', ('gre', None): 'ell', ('srp', None): 'scc', ('srp', 'ME'): 'mne'}
self.from_opensubtitles = CaseInsensitiveDict({'pob': ('por', 'BR'), 'pb': ('por', 'BR'), 'ell': ('ell', None),
'scc': ('srp', None), 'mne': ('srp', 'ME')})
self.codes = (self.alpha2_converter.codes | self.alpha3b_converter.codes | set(['pob', 'pb', 'scc', 'mne']))
def convert(self, alpha3, country=None, script=None):
alpha3b = self.alpha3b_converter.convert(alpha3, country, script)
if (alpha3b, country) in self.to_opensubtitles:
return self.to_opensubtitles[(alpha3b, country)]
return alpha3b
def reverse(self, opensubtitles):
if opensubtitles in self.from_opensubtitles:
return self.from_opensubtitles[opensubtitles]
for conv in [self.alpha3b_converter, self.alpha2_converter]:
try:
return conv.reverse(opensubtitles)
except LanguageReverseError:
pass
raise LanguageReverseError(opensubtitles)
| gpl-3.0 |
shssoichiro/servo | tests/wpt/web-platform-tests/webvtt/parsing/cue-text-parsing/buildtests.py | 75 | 1952 | #!/usr/bin/python
import os
import urllib
import hashlib
doctmpl = """<!doctype html>
<title>WebVTT cue data parser test %s</title>
<style>video { display:none }</style>
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script src=/html/syntax/parsing/template.js></script>
<script src=/html/syntax/parsing/common.js></script>
<script src=../common.js></script>
<div id=log></div>
<script>
runTests([
%s
]);
</script>"""
testobj = "{name:'%s', input:'%s', expected:'%s'}"
def appendtest(tests, input, expected):
tests.append(testobj % (hashlib.sha1(input).hexdigest(), urllib.quote(input[:-1]), urllib.quote(expected[:-1])))
files = os.listdir('dat/')
for file in files:
if os.path.isdir('dat/'+file) or file[0] == ".":
continue
tests = []
input = ""
expected = ""
state = ""
f = open('dat/'+file, "r")
while 1:
line = f.readline()
if not line:
if state != "":
appendtest(tests, input, expected)
input = ""
expected = ""
state = ""
break
if line[0] == "#":
state = line
if line == "#document-fragment\n":
expected = expected + line
elif state == "#data\n":
input = input + line
elif state == "#errors\n":
pass
elif state == "#document-fragment\n":
if line == "\n":
appendtest(tests, input, expected)
input = ""
expected = ""
state = ""
else:
expected = expected + line
else:
raise Exception("failed to parse file "+file+" line:"+line+" (state: "+state+")")
f.close()
barename = file.replace(".dat", "")
out = open('tests/'+barename+".html", "w")
out.write(doctmpl % (barename, ",\n".join(tests)))
out.close()
| mpl-2.0 |
Mitroman/Zurvival | main.py | 1 | 6007 | #!/usr/bin/env python3
import pygame, os, random, easygui
from pygame.sprite import spritecollide, RenderClear
from sprites import *
chance = 0
chance_ammo = 0
easygui.msgbox(msg="""Zurvival!\nDies ist ein Überlebensspiel wo man Zombies töten muss, Munition sammeln und überleben muss!\n
Steuerung:\nW: Vorwärts\nS:Rückwärts\nA:Links\nD:Rechts\nR:Nachladen\nY:Screenshot\nViel Spaß!""")
answer = easygui.choicebox(msg="Wähle die Schwierigkeit!", choices=("Leicht", "Mittel", "Schwer"))
if answer == "Leicht":
chance = 150
chance_ammo = 25
elif answer == "Mittel":
chance = 100
chance_ammo = 50
elif answer == "Schwer":
chance = 50
chance_ammo = 75
if chance == 0 and chance_ammo == 0:
print("Abbruch.")
exit(0)
pygame.init()
screen = pygame.display.set_mode((640, 480))
try:
background = pygame.image.load(os.path.join("img", "background.png"))
except:
background = pygame.Surface((640, 480))
background.fill((85, 185, 0))
screen.blit(background, (0, 0))
players = RenderClear()
enemys = RenderClear()
dumbs = RenderClear()
shots = RenderClear()
player = Player()
players.add(player)
for i in range(random.randint(3, 4)):
dumbs.add(Dumb())
speed = 3
look = "right"
punched = False
timer = 0
punkte = 0
god = False
while True:
event = pygame.event.poll()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_w:
player.direction[1] = -speed
try:
player.image = pygame.image.load(os.path.join("img", "player_up.png"))
except:
pass
look = "up"
if event.key == pygame.K_s:
player.direction[1] = speed
try:
player.image = pygame.image.load(os.path.join("img", "player_down.png"))
except:
pass
look = "down"
if event.key == pygame.K_a:
player.direction[0] = -speed
try:
player.image = pygame.image.load(os.path.join("img", "player_left.png"))
except:
pass
look = "left"
if event.key == pygame.K_d:
player.direction[0] = speed
try:
player.image = pygame.image.load(os.path.join("img", "player_right.png"))
except:
pass
look = "right"
if event.key == pygame.K_r and player.max_ammo > 0 and player.loaded_ammo == 0:
player.max_ammo -= 8
player.loaded_ammo = 8
print("Ammo: %i/%i" % (player.loaded_ammo, player.max_ammo))
if player.loaded_ammo == 0:
print("Nachladen!")
if event.key == pygame.K_SPACE and player.loaded_ammo > 0:
if look == "right":
shot = Shot((player.rect.topleft[0] + player.image.get_width() + 1, player.rect.topleft[1] + (player.image.get_height() / 2)))
shot.direction[0] = 5
if look == "left":
shot = Shot((player.rect.topleft[0] - 1, player.rect.topleft[1] + (player.image.get_height() / 2)))
shot.direction[0] = -5
if look == "up":
shot = Shot((player.rect.topleft[0] + (player.image.get_width() / 2), player.rect.topleft[1] + 1))
shot.direction[1] = -5
if look == "down":
shot = Shot((player.rect.topleft[0] + (player.image.get_width() / 2), player.rect.topleft[1] + player.image.get_height() + 1))
shot.direction[1] = 5
shots.add(shot)
if not god:
player.loaded_ammo -= 1
if event.key == pygame.K_ESCAPE:
print("Abbruch")
exit(0)
if event.key == pygame.K_y:
pygame.image.save(screen, "screenshot.JPEG")
print("Screenshot!")
if event.key == pygame.K_g:
if not god:
print("Godmode on!")
god = True
else:
print("Godmode off!")
god = False
elif event.type == pygame.KEYUP:
if event.key == pygame.K_w:
player.direction[1] = 0
if event.key == pygame.K_s:
player.direction[1] = 0
if event.key == pygame.K_a:
player.direction[0] = 0
if event.key == pygame.K_d:
player.direction[0] = 0
if random.randint(1, chance) == 1:
enemys.add(Enemy())
for enemy in enemys:
if spritecollide(enemy, shots, True):
background.blit(pygame.image.load(os.path.join("img", "blood.png")), enemy.rect.topleft)
enemy.kill()
punkte += 1
if spritecollide(enemy, players, False) and not punched and not god:
player.life -= 1
punched = True
if player.life == 0:
print("Game Over")
easygui.msgbox(msg="Super!\nDu hast %s Punkte erreicht!" % (punkte))
exit(0)
print("Autsch! Leben: %i" % (player.life))
if spritecollide(enemy, dumbs, False):
try:
enemy.rect.topleft = (enemy.old[0], enemy.old[1])
except:
pass
if punched:
timer += 1
if timer == 25:
punched = False
timer = 0
if spritecollide(player, dumbs, False):
if random.randint(1, chance_ammo) == 1 and player.max_ammo < 24:
player.max_ammo += 8
print("Munition gefunden!")
print("Ammo: %i/%i" % (player.loaded_ammo, player.max_ammo))
if spritecollide(player, dumbs, False):
try:
player.rect.topleft = (player.old[0], player.old[1])
except:
pass
for obj in (players, dumbs, shots, enemys):
obj.clear(screen, background)
if obj == enemys:
obj.update(player.rect.topleft)
else:
obj.update()
obj.draw(screen)
pygame.display.update()
pygame.time.delay(20)
| gpl-2.0 |
jonashagstedt/django-reform | demo/settings.py | 1 | 2385 | """
Django settings for django_reform project.
For more information on this file, see
https://docs.djangoproject.com/en/1.7/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.7/ref/settings/
"""
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
from os.path import join
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.7/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'd-=y9ikn60t2u82u30m$()8zua8&sh5g_m8in(i=)(ew*8h!f@'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
TEMPLATE_DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'reform',
'django_reform.app',
)
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
)
ROOT_URLCONF = 'django_reform.urls'
WSGI_APPLICATION = 'django_reform.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.7/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Internationalization
# https://docs.djangoproject.com/en/1.7/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.7/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = join(BASE_DIR, 'static_root')
MEDIA_URL = '/media/'
MEDIA_ROOT = join(BASE_DIR, 'media')
# Additional locations of static files
STATICFILES_DIRS = [join(BASE_DIR, 'static')]
TEMPLATE_DIRS = [join(BASE_DIR, 'templates')] | bsd-3-clause |
kenshay/ImageScript | ProgramData/Android/ADB/platform-tools/systrace/catapult/telemetry/third_party/web-page-replay/third_party/dns/rdtypes/IN/NAPTR.py | 248 | 4889 | # Copyright (C) 2003-2007, 2009, 2010 Nominum, Inc.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose with or without fee is hereby granted,
# provided that the above copyright notice and this permission notice
# appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
import struct
import dns.exception
import dns.name
import dns.rdata
def _write_string(file, s):
l = len(s)
assert l < 256
byte = chr(l)
file.write(byte)
file.write(s)
class NAPTR(dns.rdata.Rdata):
"""NAPTR record
@ivar order: order
@type order: int
@ivar preference: preference
@type preference: int
@ivar flags: flags
@type flags: string
@ivar service: service
@type service: string
@ivar regexp: regular expression
@type regexp: string
@ivar replacement: replacement name
@type replacement: dns.name.Name object
@see: RFC 3403"""
__slots__ = ['order', 'preference', 'flags', 'service', 'regexp',
'replacement']
def __init__(self, rdclass, rdtype, order, preference, flags, service,
regexp, replacement):
super(NAPTR, self).__init__(rdclass, rdtype)
self.order = order
self.preference = preference
self.flags = flags
self.service = service
self.regexp = regexp
self.replacement = replacement
def to_text(self, origin=None, relativize=True, **kw):
replacement = self.replacement.choose_relativity(origin, relativize)
return '%d %d "%s" "%s" "%s" %s' % \
(self.order, self.preference,
dns.rdata._escapify(self.flags),
dns.rdata._escapify(self.service),
dns.rdata._escapify(self.regexp),
self.replacement)
def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True):
order = tok.get_uint16()
preference = tok.get_uint16()
flags = tok.get_string()
service = tok.get_string()
regexp = tok.get_string()
replacement = tok.get_name()
replacement = replacement.choose_relativity(origin, relativize)
tok.get_eol()
return cls(rdclass, rdtype, order, preference, flags, service,
regexp, replacement)
from_text = classmethod(from_text)
def to_wire(self, file, compress = None, origin = None):
two_ints = struct.pack("!HH", self.order, self.preference)
file.write(two_ints)
_write_string(file, self.flags)
_write_string(file, self.service)
_write_string(file, self.regexp)
self.replacement.to_wire(file, compress, origin)
def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None):
(order, preference) = struct.unpack('!HH', wire[current : current + 4])
current += 4
rdlen -= 4
strings = []
for i in xrange(3):
l = ord(wire[current])
current += 1
rdlen -= 1
if l > rdlen or rdlen < 0:
raise dns.exception.FormError
s = wire[current : current + l]
current += l
rdlen -= l
strings.append(s)
(replacement, cused) = dns.name.from_wire(wire[: current + rdlen],
current)
if cused != rdlen:
raise dns.exception.FormError
if not origin is None:
replacement = replacement.relativize(origin)
return cls(rdclass, rdtype, order, preference, strings[0], strings[1],
strings[2], replacement)
from_wire = classmethod(from_wire)
def choose_relativity(self, origin = None, relativize = True):
self.replacement = self.replacement.choose_relativity(origin,
relativize)
def _cmp(self, other):
sp = struct.pack("!HH", self.order, self.preference)
op = struct.pack("!HH", other.order, other.preference)
v = cmp(sp, op)
if v == 0:
v = cmp(self.flags, other.flags)
if v == 0:
v = cmp(self.service, other.service)
if v == 0:
v = cmp(self.regexp, other.regexp)
if v == 0:
v = cmp(self.replacement, other.replacement)
return v
| gpl-3.0 |
SummerLW/Perf-Insight-Report | third_party/gsutil/third_party/boto/boto/ec2/elb/securitygroup.py | 152 | 1576 | # Copyright (c) 2010 Reza Lotun http://reza.lotun.name
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
class SecurityGroup(object):
def __init__(self, connection=None):
self.name = None
self.owner_alias = None
def __repr__(self):
return 'SecurityGroup(%s, %s)' % (self.name, self.owner_alias)
def startElement(self, name, attrs, connection):
pass
def endElement(self, name, value, connection):
if name == 'GroupName':
self.name = value
elif name == 'OwnerAlias':
self.owner_alias = value
| bsd-3-clause |
sbusso/rethinkdb | external/v8_3.30.33.16/build/gyp/test/win/gyptest-link-base-address.py | 137 | 1816 | #!/usr/bin/env python
# Copyright 2013 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Make sure the base address setting is extracted properly.
"""
import TestGyp
import re
import sys
if sys.platform == 'win32':
test = TestGyp.TestGyp(formats=['msvs', 'ninja'])
CHDIR = 'linker-flags'
test.run_gyp('base-address.gyp', chdir=CHDIR)
test.build('base-address.gyp', test.ALL, chdir=CHDIR)
def GetHeaders(exe):
full_path = test.built_file_path(exe, chdir=CHDIR)
return test.run_dumpbin('/headers', full_path)
# Extract the image base address from the headers output.
image_base_reg_ex = re.compile('.*\s+([0-9]+) image base.*', re.DOTALL)
exe_headers = GetHeaders('test_base_specified_exe.exe')
exe_match = image_base_reg_ex.match(exe_headers)
if not exe_match or not exe_match.group(1):
test.fail_test()
if exe_match.group(1) != '420000':
test.fail_test()
dll_headers = GetHeaders('test_base_specified_dll.dll')
dll_match = image_base_reg_ex.match(dll_headers)
if not dll_match or not dll_match.group(1):
test.fail_test()
if dll_match.group(1) != '10420000':
test.fail_test()
default_exe_headers = GetHeaders('test_base_default_exe.exe')
default_exe_match = image_base_reg_ex.match(default_exe_headers)
if not default_exe_match or not default_exe_match.group(1):
test.fail_test()
if default_exe_match.group(1) != '400000':
test.fail_test()
default_dll_headers = GetHeaders('test_base_default_dll.dll')
default_dll_match = image_base_reg_ex.match(default_dll_headers)
if not default_dll_match or not default_dll_match.group(1):
test.fail_test()
if default_dll_match.group(1) != '10000000':
test.fail_test()
test.pass_test()
| agpl-3.0 |
moraesnicol/scrapy | tests/test_dupefilters.py | 110 | 2315 | import hashlib
import tempfile
import unittest
import shutil
from scrapy.dupefilters import RFPDupeFilter
from scrapy.http import Request
from scrapy.utils.python import to_bytes
class RFPDupeFilterTest(unittest.TestCase):
def test_filter(self):
dupefilter = RFPDupeFilter()
dupefilter.open()
r1 = Request('http://scrapytest.org/1')
r2 = Request('http://scrapytest.org/2')
r3 = Request('http://scrapytest.org/2')
assert not dupefilter.request_seen(r1)
assert dupefilter.request_seen(r1)
assert not dupefilter.request_seen(r2)
assert dupefilter.request_seen(r3)
dupefilter.close('finished')
def test_dupefilter_path(self):
r1 = Request('http://scrapytest.org/1')
r2 = Request('http://scrapytest.org/2')
path = tempfile.mkdtemp()
try:
df = RFPDupeFilter(path)
df.open()
assert not df.request_seen(r1)
assert df.request_seen(r1)
df.close('finished')
df2 = RFPDupeFilter(path)
df2.open()
assert df2.request_seen(r1)
assert not df2.request_seen(r2)
assert df2.request_seen(r2)
df2.close('finished')
finally:
shutil.rmtree(path)
def test_request_fingerprint(self):
"""Test if customization of request_fingerprint method will change
output of request_seen.
"""
r1 = Request('http://scrapytest.org/index.html')
r2 = Request('http://scrapytest.org/INDEX.html')
dupefilter = RFPDupeFilter()
dupefilter.open()
assert not dupefilter.request_seen(r1)
assert not dupefilter.request_seen(r2)
dupefilter.close('finished')
class CaseInsensitiveRFPDupeFilter(RFPDupeFilter):
def request_fingerprint(self, request):
fp = hashlib.sha1()
fp.update(to_bytes(request.url.lower()))
return fp.hexdigest()
case_insensitive_dupefilter = CaseInsensitiveRFPDupeFilter()
case_insensitive_dupefilter.open()
assert not case_insensitive_dupefilter.request_seen(r1)
assert case_insensitive_dupefilter.request_seen(r2)
case_insensitive_dupefilter.close('finished')
| bsd-3-clause |
ging/fiware-chef_validator | chef_validator/tests/unit/api/base.py | 2 | 2426 | # -*- coding: utf-8 -*-
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import logging
import fixtures
import mock
from oslo_utils import timeutils
from chef_validator.tests.unit import base
TEST_DEFAULT_LOGLEVELS = {'migrate': logging.WARN}
class FakeLogMixin(object):
"""Allow logs to be tested (rather than just disabling
logging.
"""
def setup_logging(self):
# Assign default logs to self.LOG so we can still
# assert on chef_validator logs.
self.LOG = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
base_list = set([nlog.split('.')[0]
for nlog in logging.Logger.manager.loggerDict])
for base_name in base_list:
if base_name in TEST_DEFAULT_LOGLEVELS:
self.useFixture(fixtures.FakeLogger(
level=TEST_DEFAULT_LOGLEVELS[base_name], name=base_name))
elif base_name != 'chef_validator':
self.useFixture(fixtures.FakeLogger(name=base_name))
class ApiClient(object):
pass
class ValidatorApiTestCase(base.ValidatorTestCase, FakeLogMixin):
# Set this if common.rpc is imported into other scopes so that
# it can be mocked properly
def setUp(self):
super(ValidatorApiTestCase, self).setUp()
self.setup_logging()
# Mock the API Classes
self.mock_api = mock.Mock(ApiClient)
mock.patch('chef_validator.api', return_value=self.mock_api).start()
self.addCleanup(mock.patch.stopall)
def tearDown(self):
super(ValidatorApiTestCase, self).tearDown()
timeutils.utcnow.override_time = None
def _stub_uuid(self, values=[]):
class FakeUUID(object):
def __init__(self, v):
self.hex = v
mock_uuid4 = mock.patch('uuid.uuid4').start()
mock_uuid4.side_effect = [FakeUUID(v) for v in values]
return mock_uuid4
| apache-2.0 |
SymbiFlow/prjxray | fuzzers/033-mon-xadc/top.py | 1 | 2269 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (C) 2017-2020 The Project X-Ray Authors.
#
# Use of this source code is governed by a ISC-style
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/ISC
#
# SPDX-License-Identifier: ISC
import os
import random
random.seed(int(os.getenv("SEED"), 16))
from prjxray import util
from prjxray import verilog
from prjxray.verilog import vrandbit, vrandbits
import sys
import json
def gen_sites():
for _tile_name, site_name, _site_type in sorted(util.get_roi().gen_sites(
["XADC"])):
yield site_name
sites = list(gen_sites())
DUTN = len(sites)
DIN_N = DUTN * 8
DOUT_N = DUTN * 8
verilog.top_harness(DIN_N, DOUT_N)
f = open('params.jl', 'w')
f.write('module,loc,params\n')
print(
'module roi(input clk, input [%d:0] din, output [%d:0] dout);' %
(DIN_N - 1, DOUT_N - 1))
for loci, site in enumerate(sites):
ports = {
'clk': 'clk',
'din': 'din[ %d +: 8]' % (8 * loci, ),
'dout': 'dout[ %d +: 8]' % (8 * loci, ),
}
params = {
"INIT_43": random.randint(0x000, 0xFFFF),
}
modname = "my_XADC"
verilog.instance(modname, "inst_%u" % loci, ports, params=params)
# LOC isn't support
params["LOC"] = verilog.quote(site)
j = {'module': modname, 'i': loci, 'params': params}
f.write('%s\n' % (json.dumps(j)))
print('')
f.close()
print(
'''endmodule
// ---------------------------------------------------------------------
''')
print(
'''
module my_XADC (input clk, input [7:0] din, output [7:0] dout);
parameter INIT_43 = 16'h0000;
(* KEEP, DONT_TOUCH *)
XADC #(
.INIT_43(INIT_43)
) dut (
.BUSY(),
.DRDY(),
.EOC(),
.EOS(),
.JTAGBUSY(),
.JTAGLOCKED(),
.JTAGMODIFIED(),
.OT(),
.DO(),
.ALM(),
.CHANNEL(),
.MUXADDR(),
.CONVST(),
.CONVSTCLK(clk),
.DCLK(clk),
.DEN(),
.DWE(),
.RESET(),
.VN(),
.VP(),
.DI(),
.VAUXN(),
.VAUXP(),
.DADDR());
endmodule
''')
| isc |
fabric-bolt/fabric-bolt | fabric_bolt/core/views.py | 10 | 3516 | from datetime import timedelta, datetime
from django.utils import timezone
from django.db.models.aggregates import Count
from django.contrib import messages
from django.views.generic import TemplateView
from django.template.defaultfilters import date as format_date
from django.template.defaultfilters import time as format_time
from graphos.renderers.gchart import PieChart, LineChart
from graphos.sources.simple import SimpleDataSource
from croniter import croniter
from fabric_bolt.launch_window.models import LaunchWindow
from fabric_bolt.projects.models import Project, Deployment
class Dashboard(TemplateView):
template_name = 'dashboard.html'
def get_context_data(self, **kwargs):
context = super(Dashboard, self).get_context_data(**kwargs)
# Warn the user if we don't have an available Launch Window
has_one_window = False
next_window = None
launch_windows = LaunchWindow.objects.all()
for window in launch_windows:
current_date = datetime.now()
next_window = croniter(window.cron_format, current_date).get_next(datetime)
if (next_window - datetime.now()).seconds < 61:
has_one_window = True
break
if not has_one_window and launch_windows.exists():
messages.add_message(self.request, messages.ERROR,
'No available Launch Windows! Next window on %s @ %s' % (format_date(next_window), format_time(next_window)))
# Deployment Stats Data
# Build pie chart data to show % projects deployed successfully
deployments = Deployment.active_records.order_by('status').values('status').annotate(count=Count('id'))
items = [['string', 'number']] + [
[item['status'], item['count']] for item in deployments
]
context['pie_chart'] = PieChart(SimpleDataSource(items), width='100%', height=300, options={'title': ''})
# Deployment History Data
# Get all projects with the days they were deployed and the count of the deploys on each day
chart_data = []
projects = list(Project.active_records.all())
if len(projects) == 0:
return context
deploys = list(Deployment.objects.select_related('stage').order_by('date_created'))
# Get the date range for all the deployments ever done
start_date = (timezone.now() - timedelta(days=60)).date()
end_date = timezone.now().date()
# Step through each day and create an array of deployment counts from each project
# this would be much easier if we could aggregate by day.
# once we can use django 1.7, we could write a __date transform. Then it would work.
for day in range(-1, (end_date - start_date).days + 1):
date = start_date + timedelta(days=day)
if day == -1:
data = ['Day']
else:
data = [date.strftime('%m/%d')]
for project in projects:
if day == -1:
data.append(project.name)
continue
count = 0
for d in deploys:
if d.stage.project_id == project.pk and d.date_created.date() == date:
count += 1
data.append(count)
chart_data.append(data)
context['line_chart'] = LineChart(SimpleDataSource(chart_data), width='100%', height=300, options={'title': ''})
return context | mit |
glovebx/odoo | addons/website_twitter/controllers/main.py | 355 | 1936 | from openerp.addons.web import http
from openerp.addons.web.http import request
from openerp.tools.translate import _
import json
class Twitter(http.Controller):
@http.route(['/twitter_reload'], type='json', auth="user", website=True)
def twitter_reload(self):
return request.website.fetch_favorite_tweets()
@http.route(['/get_favorites'], type='json', auth="public", website=True)
def get_tweets(self, limit=20):
key = request.website.twitter_api_key
secret = request.website.twitter_api_secret
screen_name = request.website.twitter_screen_name
cr, uid = request.cr, request.uid
debug = request.registry['res.users'].has_group(cr, uid, 'base.group_website_publisher')
if not key or not secret:
if debug:
return {"error": _("Please set the Twitter API Key and Secret in the Website Settings.")}
return []
if not screen_name:
if debug:
return {"error": _("Please set a Twitter screen name to load favorites from, "
"in the Website Settings (it does not have to be yours)")}
return []
twitter_tweets = request.registry['website.twitter.tweet']
tweets = twitter_tweets.search_read(
cr, uid,
[('website_id','=', request.website.id),
('screen_name','=', screen_name)],
['tweet'], limit=int(limit), order="tweet_id desc", context=request.context)
if len(tweets) < 12:
if debug:
return {"error": _("Twitter user @%(username)s has less than 12 favorite tweets. "
"Please add more or choose a different screen name.") % \
{'username': screen_name}}
else:
return []
return [json.loads(tweet['tweet']) for tweet in tweets]
| agpl-3.0 |
yyzybb537/libgo | third_party/boost.context/tools/build/test/absolute_sources.py | 44 | 1867 | #!/usr/bin/python
# Copyright 2003, 2004 Vladimir Prus
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
# Test that sources with absolute names are handled OK.
import BoostBuild
t = BoostBuild.Tester(use_test_config=False)
t.write("jamroot.jam", "path-constant TOP : . ;")
t.write("jamfile.jam", """\
local pwd = [ PWD ] ;
ECHO $(pwd) XXXXX ;
exe hello : $(pwd)/hello.cpp $(TOP)/empty.cpp ;
""")
t.write("hello.cpp", "int main() {}\n")
t.write("empty.cpp", "\n")
t.run_build_system()
t.expect_addition("bin/$toolset/debug/hello.exe")
t.rm(".")
# Test a contrived case in which an absolute name is used in a standalone
# project (not Jamfile). Moreover, the target with an absolute name is returned
# via an 'alias' and used from another project.
t.write("a.cpp", "int main() {}\n")
t.write("jamfile.jam", "exe a : /standalone//a ;")
t.write("jamroot.jam", "import standalone ;")
t.write("standalone.jam", """\
import project ;
project.initialize $(__name__) ;
project standalone ;
local pwd = [ PWD ] ;
alias a : $(pwd)/a.cpp ;
""")
t.write("standalone.py", """
from b2.manager import get_manager
# FIXME: this is ugly as death
get_manager().projects().initialize(__name__)
import os ;
# This use of list as parameter is also ugly.
project(['standalone'])
pwd = os.getcwd()
alias('a', [os.path.join(pwd, 'a.cpp')])
""")
t.run_build_system()
t.expect_addition("bin/$toolset/debug/a.exe")
# Test absolute path in target ids.
t.rm(".")
t.write("d1/jamroot.jam", "")
t.write("d1/jamfile.jam", "exe a : a.cpp ;")
t.write("d1/a.cpp", "int main() {}\n")
t.write("d2/jamroot.jam", "")
t.write("d2/jamfile.jam", """\
local pwd = [ PWD ] ;
alias x : $(pwd)/../d1//a ;
""")
t.run_build_system(subdir="d2")
t.expect_addition("d1/bin/$toolset/debug/a.exe")
t.cleanup()
| mit |
proversity-org/edx-platform | common/djangoapps/course_action_state/tests/test_managers.py | 24 | 7220 | # pylint: disable=invalid-name, attribute-defined-outside-init
"""
Tests for basic common operations related to Course Action State managers
"""
from collections import namedtuple
from ddt import data, ddt
from django.test import TestCase
from opaque_keys.edx.locations import CourseLocator
from course_action_state.managers import CourseActionStateItemNotFoundError
from course_action_state.models import CourseRerunState
# Sequence of Action models to be tested with ddt.
COURSE_ACTION_STATES = (CourseRerunState, )
class TestCourseActionStateManagerBase(TestCase):
"""
Base class for testing Course Action State Managers.
"""
def setUp(self):
super(TestCourseActionStateManagerBase, self).setUp()
self.course_key = CourseLocator("test_org", "test_course_num", "test_run")
@ddt
class TestCourseActionStateManager(TestCourseActionStateManagerBase):
"""
Test class for testing the CourseActionStateManager.
"""
@data(*COURSE_ACTION_STATES)
def test_update_state_allow_not_found_is_false(self, action_class):
with self.assertRaises(CourseActionStateItemNotFoundError):
action_class.objects.update_state(self.course_key, "fake_state", allow_not_found=False)
@data(*COURSE_ACTION_STATES)
def test_update_state_allow_not_found(self, action_class):
action_class.objects.update_state(self.course_key, "initial_state", allow_not_found=True)
self.assertIsNotNone(
action_class.objects.find_first(course_key=self.course_key)
)
@data(*COURSE_ACTION_STATES)
def test_delete(self, action_class):
obj = action_class.objects.update_state(self.course_key, "initial_state", allow_not_found=True)
action_class.objects.delete(obj.id)
with self.assertRaises(CourseActionStateItemNotFoundError):
action_class.objects.find_first(course_key=self.course_key)
@ddt
class TestCourseActionUIStateManager(TestCourseActionStateManagerBase):
"""
Test class for testing the CourseActionUIStateManager.
"""
def init_course_action_states(self, action_class):
"""
Creates course action state entries with different states for the given action model class.
Creates both displayable (should_display=True) and non-displayable (should_display=False) entries.
"""
def create_course_states(starting_course_num, ending_course_num, state, should_display=True):
"""
Creates a list of course state tuples by creating unique course locators with course-numbers
from starting_course_num to ending_course_num.
"""
CourseState = namedtuple('CourseState', 'course_key, state, should_display')
return [
CourseState(CourseLocator("org", "course", "run" + str(num)), state, should_display)
for num in range(starting_course_num, ending_course_num)
]
NUM_COURSES_WITH_STATE1 = 3
NUM_COURSES_WITH_STATE2 = 3
NUM_COURSES_WITH_STATE3 = 3
NUM_COURSES_NON_DISPLAYABLE = 3
# courses with state1 and should_display=True
self.courses_with_state1 = create_course_states(
0,
NUM_COURSES_WITH_STATE1,
'state1'
)
# courses with state2 and should_display=True
self.courses_with_state2 = create_course_states(
NUM_COURSES_WITH_STATE1,
NUM_COURSES_WITH_STATE1 + NUM_COURSES_WITH_STATE2,
'state2'
)
# courses with state3 and should_display=True
self.courses_with_state3 = create_course_states(
NUM_COURSES_WITH_STATE1 + NUM_COURSES_WITH_STATE2,
NUM_COURSES_WITH_STATE1 + NUM_COURSES_WITH_STATE2 + NUM_COURSES_WITH_STATE3,
'state3'
)
# all courses with should_display=True
self.course_actions_displayable_states = (
self.courses_with_state1 + self.courses_with_state2 + self.courses_with_state3
)
# courses with state3 and should_display=False
self.courses_with_state3_non_displayable = create_course_states(
NUM_COURSES_WITH_STATE1 + NUM_COURSES_WITH_STATE2 + NUM_COURSES_WITH_STATE3,
NUM_COURSES_WITH_STATE1 + NUM_COURSES_WITH_STATE2 + NUM_COURSES_WITH_STATE3 + NUM_COURSES_NON_DISPLAYABLE,
'state3',
should_display=False,
)
# create course action states for all courses
for CourseState in self.course_actions_displayable_states + self.courses_with_state3_non_displayable:
action_class.objects.update_state(
CourseState.course_key,
CourseState.state,
should_display=CourseState.should_display,
allow_not_found=True
)
def assertCourseActionStatesEqual(self, expected, found):
"""Asserts that the set of course keys in the expected state equal those that are found"""
self.assertSetEqual(
set(course_action_state.course_key for course_action_state in expected),
set(course_action_state.course_key for course_action_state in found))
@data(*COURSE_ACTION_STATES)
def test_find_all_for_display(self, action_class):
self.init_course_action_states(action_class)
self.assertCourseActionStatesEqual(
self.course_actions_displayable_states,
action_class.objects.find_all(should_display=True),
)
@data(*COURSE_ACTION_STATES)
def test_find_all_for_display_filter_exclude(self, action_class):
self.init_course_action_states(action_class)
for course_action_state, filter_state, exclude_state in (
(self.courses_with_state1, 'state1', None), # filter for state1
(self.courses_with_state2, 'state2', None), # filter for state2
(self.courses_with_state2 + self.courses_with_state3, None, 'state1'), # exclude state1
(self.courses_with_state1 + self.courses_with_state3, None, 'state2'), # exclude state2
(self.courses_with_state1, 'state1', 'state2'), # filter for state1, exclude state2
([], 'state1', 'state1'), # filter for state1, exclude state1
):
self.assertCourseActionStatesEqual(
course_action_state,
action_class.objects.find_all(
exclude_args=({'state': exclude_state} if exclude_state else None),
should_display=True,
**({'state': filter_state} if filter_state else {})
)
)
def test_kwargs_in_update_state(self):
destination_course_key = CourseLocator("org", "course", "run")
source_course_key = CourseLocator("source_org", "source_course", "source_run")
CourseRerunState.objects.update_state(
course_key=destination_course_key,
new_state='state1',
allow_not_found=True,
source_course_key=source_course_key,
)
found_action_state = CourseRerunState.objects.find_first(course_key=destination_course_key)
self.assertEquals(source_course_key, found_action_state.source_course_key)
| agpl-3.0 |
google-code/android-scripting | python/src/Mac/Modules/qd/qdsupport.py | 39 | 12758 | # This script generates a Python interface for an Apple Macintosh Manager.
# It uses the "bgen" package to generate C code.
# The function specifications are generated by scanning the mamager's header file,
# using the "scantools" package (customized for this particular manager).
import string
# Declarations that change for each manager
MACHEADERFILE = 'QuickDraw.h' # The Apple header file
MODNAME = '_Qd' # The name of the module
OBJECTNAME = 'Graf' # The basic name of the objects used here
# The following is *usually* unchanged but may still require tuning
MODPREFIX = 'Qd' # The prefix for module-wide routines
OBJECTTYPE = OBJECTNAME + 'Ptr' # The C type used to represent them
OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods
INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
EXTRAFILE = string.lower(MODPREFIX) + 'edit.py' # A similar file but hand-made
OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
from macsupport import *
# Create the type objects
class TextThingieClass(FixedInputBufferType):
def getargsCheck(self, name):
Output("/* Fool compiler warnings */")
Output("%s__in_len__ = %s__in_len__;", name, name)
def declareSize(self, name):
Output("int %s__in_len__;", name)
TextThingie = TextThingieClass(None)
# These are temporary!
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
OptRgnHandle = OpaqueByValueType("RgnHandle", "OptResObj")
PicHandle = OpaqueByValueType("PicHandle", "ResObj")
PolyHandle = OpaqueByValueType("PolyHandle", "ResObj")
PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")
PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")
PatHandle = OpaqueByValueType("PatHandle", "ResObj")
CursHandle = OpaqueByValueType("CursHandle", "ResObj")
CCrsrHandle = OpaqueByValueType("CCrsrHandle", "ResObj")
CIconHandle = OpaqueByValueType("CIconHandle", "ResObj")
CTabHandle = OpaqueByValueType("CTabHandle", "ResObj")
ITabHandle = OpaqueByValueType("ITabHandle", "ResObj")
GDHandle = OpaqueByValueType("GDHandle", "ResObj")
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
BitMap_ptr = OpaqueByValueType("BitMapPtr", "BMObj")
const_BitMap_ptr = OpaqueByValueType("const BitMap *", "BMObj")
BitMap = OpaqueType("BitMap", "BMObj_NewCopied", "BUG")
RGBColor = OpaqueType('RGBColor', 'QdRGB')
RGBColor_ptr = RGBColor
FontInfo = OpaqueType('FontInfo', 'QdFI')
Component = OpaqueByValueType('Component', 'CmpObj')
ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')
Cursor = StructOutputBufferType('Cursor')
Cursor_ptr = StructInputBufferType('Cursor')
Pattern = StructOutputBufferType('Pattern')
Pattern_ptr = StructInputBufferType('Pattern')
PenState = StructOutputBufferType('PenState')
PenState_ptr = StructInputBufferType('PenState')
TruncCode = Type("TruncCode", "h")
includestuff = includestuff + """
#include <Carbon/Carbon.h>
#ifdef USE_TOOLBOX_OBJECT_GLUE
extern PyObject *_GrafObj_New(GrafPtr);
extern int _GrafObj_Convert(PyObject *, GrafPtr *);
extern PyObject *_BMObj_New(BitMapPtr);
extern int _BMObj_Convert(PyObject *, BitMapPtr *);
extern PyObject *_QdRGB_New(RGBColorPtr);
extern int _QdRGB_Convert(PyObject *, RGBColorPtr);
#define GrafObj_New _GrafObj_New
#define GrafObj_Convert _GrafObj_Convert
#define BMObj_New _BMObj_New
#define BMObj_Convert _BMObj_Convert
#define QdRGB_New _QdRGB_New
#define QdRGB_Convert _QdRGB_Convert
#endif
static PyObject *BMObj_NewCopied(BitMapPtr);
/*
** Parse/generate RGB records
*/
PyObject *QdRGB_New(RGBColorPtr itself)
{
return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
}
int QdRGB_Convert(PyObject *v, RGBColorPtr p_itself)
{
long red, green, blue;
if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )
return 0;
p_itself->red = (unsigned short)red;
p_itself->green = (unsigned short)green;
p_itself->blue = (unsigned short)blue;
return 1;
}
/*
** Generate FontInfo records
*/
static
PyObject *QdFI_New(FontInfo *itself)
{
return Py_BuildValue("hhhh", itself->ascent, itself->descent,
itself->widMax, itself->leading);
}
"""
finalstuff = finalstuff + """
/* Like BMObj_New, but the original bitmap data structure is copied (and
** released when the object is released)
*/
PyObject *BMObj_NewCopied(BitMapPtr itself)
{
BitMapObject *it;
BitMapPtr itself_copy;
if ((itself_copy=(BitMapPtr)malloc(sizeof(BitMap))) == NULL)
return PyErr_NoMemory();
*itself_copy = *itself;
it = (BitMapObject *)BMObj_New(itself_copy);
it->referred_bitmap = itself_copy;
return (PyObject *)it;
}
"""
variablestuff = ""
initstuff = initstuff + """
PyMac_INIT_TOOLBOX_OBJECT_NEW(BitMapPtr, BMObj_New);
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(BitMapPtr, BMObj_Convert);
PyMac_INIT_TOOLBOX_OBJECT_NEW(GrafPtr, GrafObj_New);
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GrafPtr, GrafObj_Convert);
PyMac_INIT_TOOLBOX_OBJECT_NEW(RGBColorPtr, QdRGB_New);
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(RGBColor, QdRGB_Convert);
"""
## not yet...
##
##class Region_ObjectDefinition(GlobalObjectDefinition):
## def outputCheckNewArg(self):
## Output("if (itself == NULL) return PyMac_Error(resNotFound);")
## def outputFreeIt(self, itselfname):
## Output("DisposeRegion(%s);", itselfname)
##
##class Polygon_ObjectDefinition(GlobalObjectDefinition):
## def outputCheckNewArg(self):
## Output("if (itself == NULL) return PyMac_Error(resNotFound);")
## def outputFreeIt(self, itselfname):
## Output("KillPoly(%s);", itselfname)
class MyGRObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
getsetlist = [
('visRgn',
"""RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(self->ob_itself, h));
""",
None,
"Convenience attribute: return a copy of the visible region"
), (
'clipRgn',
"""RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(self->ob_itself, h));
""",
None,
"Convenience attribute: return a copy of the clipping region"
)]
def outputCheckNewArg(self):
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
def outputCheckConvertArg(self):
Output("#if 1")
OutLbrace()
Output("WindowRef win;")
OutLbrace("if (WinObj_Convert(v, &win) && v)")
Output("*p_itself = (GrafPtr)GetWindowPort(win);")
Output("return 1;")
OutRbrace()
Output("PyErr_Clear();")
OutRbrace()
Output("#else")
OutLbrace("if (DlgObj_Check(v))")
Output("DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;")
Output("*p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));")
Output("return 1;")
OutRbrace()
OutLbrace("if (WinObj_Check(v))")
Output("WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;")
Output("*p_itself = (GrafPtr)GetWindowPort(win);")
Output("return 1;")
OutRbrace()
Output("#endif")
class MyBMObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
getsetlist = [
(
'baseAddr',
'return PyInt_FromLong((long)self->ob_itself->baseAddr);',
None,
None
), (
'rowBytes',
'return PyInt_FromLong((long)self->ob_itself->rowBytes);',
None,
None
), (
'bounds',
'return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);',
None,
None
), (
'bitmap_data',
'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));',
None,
None
), (
'pixmap_data',
'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));',
None,
None
)]
def outputCheckNewArg(self):
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
def outputStructMembers(self):
# We need to more items: a pointer to privately allocated data
# and a python object we're referring to.
Output("%s ob_itself;", self.itselftype)
Output("PyObject *referred_object;")
Output("BitMap *referred_bitmap;")
def outputInitStructMembers(self):
Output("it->ob_itself = %sitself;", self.argref)
Output("it->referred_object = NULL;")
Output("it->referred_bitmap = NULL;")
def outputCleanupStructMembers(self):
Output("Py_XDECREF(self->referred_object);")
Output("if (self->referred_bitmap) free(self->referred_bitmap);")
# Create the generator groups and link them
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff, variablestuff)
##r_object = Region_ObjectDefinition('Region', 'QdRgn', 'RgnHandle')
##po_object = Polygon_ObjectDefinition('Polygon', 'QdPgn', 'PolyHandle')
##module.addobject(r_object)
##module.addobject(po_object)
gr_object = MyGRObjectDefinition("GrafPort", "GrafObj", "GrafPtr")
module.addobject(gr_object)
bm_object = MyBMObjectDefinition("BitMap", "BMObj", "BitMapPtr")
module.addobject(bm_object)
# Create the generator classes used to populate the lists
Function = OSErrWeakLinkFunctionGenerator
Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
gr_methods = []
bm_methods = []
#methods = []
execfile(INPUTFILE)
execfile(EXTRAFILE)
# add the populated lists to the generator groups
# (in a different wordl the scan program would generate this)
for f in functions: module.add(f)
for f in gr_methods: gr_object.add(f)
for f in bm_methods: bm_object.add(f)
# Manual generator: get data out of a bitmap
getdata_body = """
int from, length;
char *cp;
if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
return NULL;
cp = _self->ob_itself->baseAddr+from;
_res = PyString_FromStringAndSize(cp, length);
return _res;
"""
f = ManualGenerator("getdata", getdata_body)
f.docstring = lambda: """(int start, int size) -> string. Return bytes from the bitmap"""
bm_object.add(f)
# Manual generator: store data in a bitmap
putdata_body = """
int from, length;
char *cp, *icp;
if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )
return NULL;
cp = _self->ob_itself->baseAddr+from;
memcpy(cp, icp, length);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
"""
f = ManualGenerator("putdata", putdata_body)
f.docstring = lambda: """(int start, string data). Store bytes into the bitmap"""
bm_object.add(f)
#
# We manually generate a routine to create a BitMap from python data.
#
BitMap_body = """
BitMap *ptr;
PyObject *source;
Rect bounds;
int rowbytes;
char *data;
if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,
&bounds) )
return NULL;
data = PyString_AsString(source);
if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )
return PyErr_NoMemory();
ptr->baseAddr = (Ptr)data;
ptr->rowBytes = rowbytes;
ptr->bounds = bounds;
if ( (_res = BMObj_New(ptr)) == NULL ) {
free(ptr);
return NULL;
}
((BitMapObject *)_res)->referred_object = source;
Py_INCREF(source);
((BitMapObject *)_res)->referred_bitmap = ptr;
return _res;
"""
f = ManualGenerator("BitMap", BitMap_body)
f.docstring = lambda: """Take (string, int, Rect) argument and create BitMap"""
module.add(f)
#
# And again, for turning a correctly-formatted structure into the object
#
RawBitMap_body = """
BitMap *ptr;
PyObject *source;
if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )
return NULL;
if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {
PyErr_Format(PyExc_TypeError,
"Argument size was %d, should be %d (sizeof BitMap) or %d (sizeof PixMap)",
PyString_Size(source), sizeof(BitMap), sizeof(PixMap));
return NULL;
}
ptr = (BitMapPtr)PyString_AsString(source);
if ( (_res = BMObj_New(ptr)) == NULL ) {
return NULL;
}
((BitMapObject *)_res)->referred_object = source;
Py_INCREF(source);
return _res;
"""
f = ManualGenerator("RawBitMap", RawBitMap_body)
f.docstring = lambda: """Take string BitMap and turn into BitMap object"""
module.add(f)
# generate output (open the output file as late as possible)
SetOutputFileName(OUTPUTFILE)
module.generate()
SetOutputFile() # Close it
| apache-2.0 |
ehashman/oh-mainline | vendor/packages/Django/django/utils/encoding.py | 80 | 9167 | from __future__ import unicode_literals
import codecs
import datetime
from decimal import Decimal
import locale
try:
from urllib.parse import quote
except ImportError: # Python 2
from urllib import quote
import warnings
from django.utils.functional import Promise
from django.utils import six
class DjangoUnicodeDecodeError(UnicodeDecodeError):
def __init__(self, obj, *args):
self.obj = obj
UnicodeDecodeError.__init__(self, *args)
def __str__(self):
original = UnicodeDecodeError.__str__(self)
return '%s. You passed in %r (%s)' % (original, self.obj,
type(self.obj))
class StrAndUnicode(object):
"""
A class that derives __str__ from __unicode__.
On Python 2, __str__ returns the output of __unicode__ encoded as a UTF-8
bytestring. On Python 3, __str__ returns the output of __unicode__.
Useful as a mix-in. If you support Python 2 and 3 with a single code base,
you can inherit this mix-in and just define __unicode__.
"""
def __init__(self, *args, **kwargs):
warnings.warn("StrAndUnicode is deprecated. Define a __str__ method "
"and apply the @python_2_unicode_compatible decorator "
"instead.", PendingDeprecationWarning, stacklevel=2)
super(StrAndUnicode, self).__init__(*args, **kwargs)
if six.PY3:
def __str__(self):
return self.__unicode__()
else:
def __str__(self):
return self.__unicode__().encode('utf-8')
def python_2_unicode_compatible(klass):
"""
A decorator that defines __unicode__ and __str__ methods under Python 2.
Under Python 3 it does nothing.
To support Python 2 and 3 with a single code base, define a __str__ method
returning text and apply this decorator to the class.
"""
if not six.PY3:
klass.__unicode__ = klass.__str__
klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
return klass
def smart_text(s, encoding='utf-8', strings_only=False, errors='strict'):
"""
Returns a text object representing 's' -- unicode on Python 2 and str on
Python 3. Treats bytestrings using the 'encoding' codec.
If strings_only is True, don't convert (some) non-string-like objects.
"""
if isinstance(s, Promise):
# The input is the result of a gettext_lazy() call.
return s
return force_text(s, encoding, strings_only, errors)
def is_protected_type(obj):
"""Determine if the object instance is of a protected type.
Objects of protected types are preserved as-is when passed to
force_text(strings_only=True).
"""
return isinstance(obj, six.integer_types + (type(None), float, Decimal,
datetime.datetime, datetime.date, datetime.time))
def force_text(s, encoding='utf-8', strings_only=False, errors='strict'):
"""
Similar to smart_text, except that lazy instances are resolved to
strings, rather than kept as lazy objects.
If strings_only is True, don't convert (some) non-string-like objects.
"""
# Handle the common case first, saves 30-40% when s is an instance of
# six.text_type. This function gets called often in that setting.
if isinstance(s, six.text_type):
return s
if strings_only and is_protected_type(s):
return s
try:
if not isinstance(s, six.string_types):
if hasattr(s, '__unicode__'):
s = s.__unicode__()
else:
if six.PY3:
if isinstance(s, bytes):
s = six.text_type(s, encoding, errors)
else:
s = six.text_type(s)
else:
s = six.text_type(bytes(s), encoding, errors)
else:
# Note: We use .decode() here, instead of six.text_type(s, encoding,
# errors), so that if s is a SafeBytes, it ends up being a
# SafeText at the end.
s = s.decode(encoding, errors)
except UnicodeDecodeError as e:
if not isinstance(s, Exception):
raise DjangoUnicodeDecodeError(s, *e.args)
else:
# If we get to here, the caller has passed in an Exception
# subclass populated with non-ASCII bytestring data without a
# working unicode method. Try to handle this without raising a
# further exception by individually forcing the exception args
# to unicode.
s = ' '.join([force_text(arg, encoding, strings_only,
errors) for arg in s])
return s
def smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
"""
Returns a bytestring version of 's', encoded as specified in 'encoding'.
If strings_only is True, don't convert (some) non-string-like objects.
"""
if isinstance(s, Promise):
# The input is the result of a gettext_lazy() call.
return s
return force_bytes(s, encoding, strings_only, errors)
def force_bytes(s, encoding='utf-8', strings_only=False, errors='strict'):
"""
Similar to smart_bytes, except that lazy instances are resolved to
strings, rather than kept as lazy objects.
If strings_only is True, don't convert (some) non-string-like objects.
"""
if isinstance(s, bytes):
if encoding == 'utf-8':
return s
else:
return s.decode('utf-8', errors).encode(encoding, errors)
if strings_only and (s is None or isinstance(s, int)):
return s
if isinstance(s, Promise):
return six.text_type(s).encode(encoding, errors)
if not isinstance(s, six.string_types):
try:
if six.PY3:
return six.text_type(s).encode(encoding)
else:
return bytes(s)
except UnicodeEncodeError:
if isinstance(s, Exception):
# An Exception subclass containing non-ASCII data that doesn't
# know how to print itself properly. We shouldn't raise a
# further exception.
return b' '.join([force_bytes(arg, encoding, strings_only,
errors) for arg in s])
return six.text_type(s).encode(encoding, errors)
else:
return s.encode(encoding, errors)
if six.PY3:
smart_str = smart_text
force_str = force_text
else:
smart_str = smart_bytes
force_str = force_bytes
# backwards compatibility for Python 2
smart_unicode = smart_text
force_unicode = force_text
smart_str.__doc__ = """\
Apply smart_text in Python 3 and smart_bytes in Python 2.
This is suitable for writing to sys.stdout (for instance).
"""
force_str.__doc__ = """\
Apply force_text in Python 3 and force_bytes in Python 2.
"""
def iri_to_uri(iri):
"""
Convert an Internationalized Resource Identifier (IRI) portion to a URI
portion that is suitable for inclusion in a URL.
This is the algorithm from section 3.1 of RFC 3987. However, since we are
assuming input is either UTF-8 or unicode already, we can simplify things a
little from the full method.
Returns an ASCII string containing the encoded result.
"""
# The list of safe characters here is constructed from the "reserved" and
# "unreserved" characters specified in sections 2.2 and 2.3 of RFC 3986:
# reserved = gen-delims / sub-delims
# gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
# sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
# / "*" / "+" / "," / ";" / "="
# unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
# Of the unreserved characters, urllib.quote already considers all but
# the ~ safe.
# The % character is also added to the list of safe characters here, as the
# end of section 3.1 of RFC 3987 specifically mentions that % must not be
# converted.
if iri is None:
return iri
return quote(force_bytes(iri), safe=b"/#%[]=:;$&()+,!?*@'~")
def filepath_to_uri(path):
"""Convert a file system path to a URI portion that is suitable for
inclusion in a URL.
We are assuming input is either UTF-8 or unicode already.
This method will encode certain chars that would normally be recognized as
special chars for URIs. Note that this method does not encode the '
character, as it is a valid character within URIs. See
encodeURIComponent() JavaScript function for more details.
Returns an ASCII string containing the encoded result.
"""
if path is None:
return path
# I know about `os.sep` and `os.altsep` but I want to leave
# some flexibility for hardcoding separators.
return quote(force_bytes(path).replace(b"\\", b"/"), safe=b"/~!*()'")
# The encoding of the default system locale but falls back to the
# given fallback encoding if the encoding is unsupported by python or could
# not be determined. See tickets #10335 and #5846
try:
DEFAULT_LOCALE_ENCODING = locale.getdefaultlocale()[1] or 'ascii'
codecs.lookup(DEFAULT_LOCALE_ENCODING)
except:
DEFAULT_LOCALE_ENCODING = 'ascii'
| agpl-3.0 |
damonkohler/sl4a | python/src/Lib/dis.py | 166 | 6484 | """Disassembler of Python byte code into mnemonics."""
import sys
import types
from opcode import *
from opcode import __all__ as _opcodes_all
__all__ = ["dis","disassemble","distb","disco"] + _opcodes_all
del _opcodes_all
def dis(x=None):
"""Disassemble classes, methods, functions, or code.
With no argument, disassemble the last traceback.
"""
if x is None:
distb()
return
if type(x) is types.InstanceType:
x = x.__class__
if hasattr(x, 'im_func'):
x = x.im_func
if hasattr(x, 'func_code'):
x = x.func_code
if hasattr(x, '__dict__'):
items = x.__dict__.items()
items.sort()
for name, x1 in items:
if type(x1) in (types.MethodType,
types.FunctionType,
types.CodeType,
types.ClassType):
print "Disassembly of %s:" % name
try:
dis(x1)
except TypeError, msg:
print "Sorry:", msg
print
elif hasattr(x, 'co_code'):
disassemble(x)
elif isinstance(x, str):
disassemble_string(x)
else:
raise TypeError, \
"don't know how to disassemble %s objects" % \
type(x).__name__
def distb(tb=None):
"""Disassemble a traceback (default: last traceback)."""
if tb is None:
try:
tb = sys.last_traceback
except AttributeError:
raise RuntimeError, "no last traceback to disassemble"
while tb.tb_next: tb = tb.tb_next
disassemble(tb.tb_frame.f_code, tb.tb_lasti)
def disassemble(co, lasti=-1):
"""Disassemble a code object."""
code = co.co_code
labels = findlabels(code)
linestarts = dict(findlinestarts(co))
n = len(code)
i = 0
extended_arg = 0
free = None
while i < n:
c = code[i]
op = ord(c)
if i in linestarts:
if i > 0:
print
print "%3d" % linestarts[i],
else:
print ' ',
if i == lasti: print '-->',
else: print ' ',
if i in labels: print '>>',
else: print ' ',
print repr(i).rjust(4),
print opname[op].ljust(20),
i = i+1
if op >= HAVE_ARGUMENT:
oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg
extended_arg = 0
i = i+2
if op == EXTENDED_ARG:
extended_arg = oparg*65536L
print repr(oparg).rjust(5),
if op in hasconst:
print '(' + repr(co.co_consts[oparg]) + ')',
elif op in hasname:
print '(' + co.co_names[oparg] + ')',
elif op in hasjrel:
print '(to ' + repr(i + oparg) + ')',
elif op in haslocal:
print '(' + co.co_varnames[oparg] + ')',
elif op in hascompare:
print '(' + cmp_op[oparg] + ')',
elif op in hasfree:
if free is None:
free = co.co_cellvars + co.co_freevars
print '(' + free[oparg] + ')',
print
def disassemble_string(code, lasti=-1, varnames=None, names=None,
constants=None):
labels = findlabels(code)
n = len(code)
i = 0
while i < n:
c = code[i]
op = ord(c)
if i == lasti: print '-->',
else: print ' ',
if i in labels: print '>>',
else: print ' ',
print repr(i).rjust(4),
print opname[op].ljust(15),
i = i+1
if op >= HAVE_ARGUMENT:
oparg = ord(code[i]) + ord(code[i+1])*256
i = i+2
print repr(oparg).rjust(5),
if op in hasconst:
if constants:
print '(' + repr(constants[oparg]) + ')',
else:
print '(%d)'%oparg,
elif op in hasname:
if names is not None:
print '(' + names[oparg] + ')',
else:
print '(%d)'%oparg,
elif op in hasjrel:
print '(to ' + repr(i + oparg) + ')',
elif op in haslocal:
if varnames:
print '(' + varnames[oparg] + ')',
else:
print '(%d)' % oparg,
elif op in hascompare:
print '(' + cmp_op[oparg] + ')',
print
disco = disassemble # XXX For backwards compatibility
def findlabels(code):
"""Detect all offsets in a byte code which are jump targets.
Return the list of offsets.
"""
labels = []
n = len(code)
i = 0
while i < n:
c = code[i]
op = ord(c)
i = i+1
if op >= HAVE_ARGUMENT:
oparg = ord(code[i]) + ord(code[i+1])*256
i = i+2
label = -1
if op in hasjrel:
label = i+oparg
elif op in hasjabs:
label = oparg
if label >= 0:
if label not in labels:
labels.append(label)
return labels
def findlinestarts(code):
"""Find the offsets in a byte code which are start of lines in the source.
Generate pairs (offset, lineno) as described in Python/compile.c.
"""
byte_increments = [ord(c) for c in code.co_lnotab[0::2]]
line_increments = [ord(c) for c in code.co_lnotab[1::2]]
lastlineno = None
lineno = code.co_firstlineno
addr = 0
for byte_incr, line_incr in zip(byte_increments, line_increments):
if byte_incr:
if lineno != lastlineno:
yield (addr, lineno)
lastlineno = lineno
addr += byte_incr
lineno += line_incr
if lineno != lastlineno:
yield (addr, lineno)
def _test():
"""Simple test program to disassemble a file."""
if sys.argv[1:]:
if sys.argv[2:]:
sys.stderr.write("usage: python dis.py [-|file]\n")
sys.exit(2)
fn = sys.argv[1]
if not fn or fn == "-":
fn = None
else:
fn = None
if fn is None:
f = sys.stdin
else:
f = open(fn)
source = f.read()
if fn is not None:
f.close()
else:
fn = "<stdin>"
code = compile(source, fn, "exec")
dis(code)
if __name__ == "__main__":
_test()
| apache-2.0 |
tiimgreen/pi_lapse | pi_lapse.py | 1 | 1121 | import subprocess
from datetime import datetime, timedelta
frame_counter = 1
# Time in seconds
# 1 Hour = 3600
# 1 Day = 86400
# Time between each photo (seconds)
time_between_frames = 60
# Duration of Time Lapse (seconds)
duration = 86400
# Image Dimensions (pixels)
image_width = 1296
image_height = 972
total_frames = duration / time_between_frames
def capture_image():
t = datetime.now()
filename = "capture_%04d-%02d-%02d_%02d-%02d-%02d.jpg" % (t.year, t.month, t.day, t.hour, t.minute, t.second)
subprocess.call("raspistill -w %d -h %d -e jpg -q 15 -o %s" % (image_width, image_height, filename), shell = True)
print("Captured Image %d of %d, named: %s" % (frame_counter, total_frames, filename))
last_capture = datetime.now()
print("========== PiLapse Started ==========")
print("A photo will be taken every %d seconds for the next %d seconds." % (time_between_frames, duration))
while frame_counter < total_frames:
if last_capture < (datetime.now() - timedelta(seconds = time_between_frames)):
last_capture = datetime.now()
capture_image()
frame_counter += 1
| mit |
AndreaCrotti/ansible | lib/ansible/plugins/cache/jsonfile.py | 77 | 4640 | # (c) 2014, Brian Coca, Josh Drake, et al
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
import os
import time
import errno
import codecs
try:
import simplejson as json
except ImportError:
import json
from ansible import constants as C
from ansible.errors import *
from ansible.parsing.utils.jsonify import jsonify
from ansible.plugins.cache.base import BaseCacheModule
class CacheModule(BaseCacheModule):
"""
A caching module backed by json files.
"""
def __init__(self, *args, **kwargs):
self._timeout = float(C.CACHE_PLUGIN_TIMEOUT)
self._cache = {}
self._cache_dir = C.CACHE_PLUGIN_CONNECTION # expects a dir path
if not self._cache_dir:
raise AnsibleError("error, fact_caching_connection is not set, cannot use fact cache")
if not os.path.exists(self._cache_dir):
try:
os.makedirs(self._cache_dir)
except (OSError,IOError) as e:
self._display.warning("error while trying to create cache dir %s : %s" % (self._cache_dir, str(e)))
return None
def get(self, key):
if key in self._cache:
return self._cache.get(key)
if self.has_expired(key):
raise KeyError
cachefile = "%s/%s" % (self._cache_dir, key)
try:
f = codecs.open(cachefile, 'r', encoding='utf-8')
except (OSError,IOError) as e:
self._display.warning("error while trying to read %s : %s" % (cachefile, str(e)))
pass
else:
try:
value = json.load(f)
self._cache[key] = value
return value
except ValueError:
self._display.warning("error while trying to write to %s : %s" % (cachefile, str(e)))
raise KeyError
finally:
f.close()
def set(self, key, value):
self._cache[key] = value
cachefile = "%s/%s" % (self._cache_dir, key)
try:
f = codecs.open(cachefile, 'w', encoding='utf-8')
except (OSError,IOError) as e:
self._display.warning("error while trying to write to %s : %s" % (cachefile, str(e)))
pass
else:
f.write(jsonify(value))
finally:
f.close()
def has_expired(self, key):
cachefile = "%s/%s" % (self._cache_dir, key)
try:
st = os.stat(cachefile)
except (OSError,IOError) as e:
if e.errno == errno.ENOENT:
return False
else:
self._display.warning("error while trying to stat %s : %s" % (cachefile, str(e)))
pass
if time.time() - st.st_mtime <= self._timeout:
return False
if key in self._cache:
del self._cache[key]
return True
def keys(self):
keys = []
for k in os.listdir(self._cache_dir):
if not (k.startswith('.') or self.has_expired(k)):
keys.append(k)
return keys
def contains(self, key):
cachefile = "%s/%s" % (self._cache_dir, key)
if key in self._cache:
return True
if self.has_expired(key):
return False
try:
st = os.stat(cachefile)
return True
except (OSError,IOError) as e:
if e.errno == errno.ENOENT:
return False
else:
self._display.warning("error while trying to stat %s : %s" % (cachefile, str(e)))
pass
def delete(self, key):
del self._cache[key]
try:
os.remove("%s/%s" % (self._cache_dir, key))
except (OSError,IOError) as e:
pass #TODO: only pass on non existing?
def flush(self):
self._cache = {}
for key in self.keys():
self.delete(key)
def copy(self):
ret = dict()
for key in self.keys():
ret[key] = self.get(key)
return ret
| gpl-3.0 |
sklnet/opendroid-enigma2 | tools/genmetaindex.py | 47 | 1108 | # usage: genmetaindex.py <xml-files> > index.xml
import sys, os
from xml.etree.ElementTree import ElementTree, Element
root = Element("index")
for file in sys.argv[1:]:
p = ElementTree()
p.parse(file)
package = Element("package")
package.set("details", os.path.basename(file))
# we need all prerequisites
package.append(p.find("prerequisites"))
info = None
# we need some of the info, but not all
for i in p.findall("info"):
if not info:
info = i
assert info
for i in info[:]:
if i.tag not in ["name", "packagename", "packagetype", "shortdescription"]:
info.remove(i)
for i in info[:]:
package.set(i.tag, i.text)
root.append(package)
def indent(elem, level=0):
i = "\n" + level*"\t"
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + "\t"
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
indent(elem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
indent(root)
ElementTree(root).write(sys.stdout)
| gpl-2.0 |
windyuuy/opera | chromium/src/third_party/python_26/Lib/site-packages/win32/scripts/backupEventLog.py | 38 | 1035 |
# Generate a base file name
import time, os
import win32api
import win32evtlog
def BackupClearLog(logType):
datePrefix = time.strftime("%Y%m%d", time.localtime(time.time()))
fileExists = 1
retry = 0
while fileExists:
if retry == 0:
index = ""
else:
index = "-%d" % retry
try:
fname = os.path.join(win32api.GetTempPath(), "%s%s-%s" % (datePrefix, index, logType) + ".evt")
os.stat(fname)
except os.error:
fileExists = 0
retry = retry + 1
# OK - have unique file name.
try:
hlog = win32evtlog.OpenEventLog(None, logType)
except win32evtlogutil.error, details:
print "Could not open the event log", details
return
try:
if win32evtlog.GetNumberOfEventLogRecords(hlog)==0:
print "No records in event log %s - not backed up" % logType
return
win32evtlog.ClearEventLog(hlog, fname)
print "Backed up %s log to %s" % (logType, fname)
finally:
win32evtlog.CloseEventLog(hlog)
if __name__=='__main__':
BackupClearLog("Application")
BackupClearLog("System")
BackupClearLog("Security")
| bsd-3-clause |
Spleen64/Sick-Beard | lib/imdb/parser/http/searchKeywordParser.py | 128 | 4331 | """
parser.http.searchKeywordParser module (imdb package).
This module provides the HTMLSearchKeywordParser class (and the
search_company_parser instance), used to parse the results of a search
for a given keyword.
E.g., when searching for the keyword "alabama", the parsed page would be:
http://akas.imdb.com/find?s=kw;mx=20;q=alabama
Copyright 2009 Davide Alberani <da@erlug.linux.it>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""
from utils import Extractor, Attribute, analyze_imdbid
from imdb.utils import analyze_title, analyze_company_name
from searchMovieParser import DOMHTMLSearchMovieParser, DOMBasicMovieParser
class DOMBasicKeywordParser(DOMBasicMovieParser):
"""Simply get the name of a keyword.
It's used by the DOMHTMLSearchKeywordParser class to return a result
for a direct match (when a search on IMDb results in a single
keyword, the web server sends directly the keyword page.
"""
# XXX: it's still to be tested!
# I'm not even sure there can be a direct hit, searching for keywords.
_titleFunct = lambda self, x: analyze_company_name(x or u'')
class DOMHTMLSearchKeywordParser(DOMHTMLSearchMovieParser):
"""Parse the html page that the IMDb web server shows when the
"new search system" is used, searching for keywords similar to
the one given."""
_BaseParser = DOMBasicKeywordParser
_notDirectHitTitle = '<title>imdb keyword'
_titleBuilder = lambda self, x: x
_linkPrefix = '/keyword/'
_attrs = [Attribute(key='data',
multi=True,
path="./a[1]/text()"
)]
extractors = [Extractor(label='search',
path="//td[3]/a[starts-with(@href, " \
"'/keyword/')]/..",
attrs=_attrs)]
def custom_analyze_title4kwd(title, yearNote, outline):
"""Return a dictionary with the needed info."""
title = title.strip()
if not title:
return {}
if yearNote:
yearNote = '%s)' % yearNote.split(' ')[0]
title = title + ' ' + yearNote
retDict = analyze_title(title)
if outline:
retDict['plot outline'] = outline
return retDict
class DOMHTMLSearchMovieKeywordParser(DOMHTMLSearchMovieParser):
"""Parse the html page that the IMDb web server shows when the
"new search system" is used, searching for movies with the given
keyword."""
_notDirectHitTitle = '<title>best'
_attrs = [Attribute(key='data',
multi=True,
path={
'link': "./a[1]/@href",
'info': "./a[1]//text()",
'ynote': "./span[@class='desc']/text()",
'outline': "./span[@class='outline']//text()"
},
postprocess=lambda x: (
analyze_imdbid(x.get('link') or u''),
custom_analyze_title4kwd(x.get('info') or u'',
x.get('ynote') or u'',
x.get('outline') or u'')
))]
extractors = [Extractor(label='search',
path="//td[3]/a[starts-with(@href, " \
"'/title/tt')]/..",
attrs=_attrs)]
_OBJECTS = {
'search_keyword_parser': ((DOMHTMLSearchKeywordParser,),
{'kind': 'keyword', '_basic_parser': DOMBasicKeywordParser}),
'search_moviekeyword_parser': ((DOMHTMLSearchMovieKeywordParser,), None)
}
| gpl-3.0 |
mancoast/CPythonPyc_test | cpython/242_test_shlex.py | 43 | 5315 | # -*- coding: iso-8859-1 -*-
import unittest
import os, sys
import shlex
from test import test_support
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
# The original test data set was from shellwords, by Hartmut Goebel.
data = r"""x|x|
foo bar|foo|bar|
foo bar|foo|bar|
foo bar |foo|bar|
foo bar bla fasel|foo|bar|bla|fasel|
x y z xxxx|x|y|z|xxxx|
\x bar|\|x|bar|
\ x bar|\|x|bar|
\ bar|\|bar|
foo \x bar|foo|\|x|bar|
foo \ x bar|foo|\|x|bar|
foo \ bar|foo|\|bar|
foo "bar" bla|foo|"bar"|bla|
"foo" "bar" "bla"|"foo"|"bar"|"bla"|
"foo" bar "bla"|"foo"|bar|"bla"|
"foo" bar bla|"foo"|bar|bla|
foo 'bar' bla|foo|'bar'|bla|
'foo' 'bar' 'bla'|'foo'|'bar'|'bla'|
'foo' bar 'bla'|'foo'|bar|'bla'|
'foo' bar bla|'foo'|bar|bla|
blurb foo"bar"bar"fasel" baz|blurb|foo"bar"bar"fasel"|baz|
blurb foo'bar'bar'fasel' baz|blurb|foo'bar'bar'fasel'|baz|
""|""|
''|''|
foo "" bar|foo|""|bar|
foo '' bar|foo|''|bar|
foo "" "" "" bar|foo|""|""|""|bar|
foo '' '' '' bar|foo|''|''|''|bar|
\""|\|""|
"\"|"\"|
"foo\ bar"|"foo\ bar"|
"foo\\ bar"|"foo\\ bar"|
"foo\\ bar\"|"foo\\ bar\"|
"foo\\" bar\""|"foo\\"|bar|\|""|
"foo\\ bar\" dfadf"|"foo\\ bar\"|dfadf"|
"foo\\\ bar\" dfadf"|"foo\\\ bar\"|dfadf"|
"foo\\\x bar\" dfadf"|"foo\\\x bar\"|dfadf"|
"foo\x bar\" dfadf"|"foo\x bar\"|dfadf"|
\''|\|''|
'foo\ bar'|'foo\ bar'|
'foo\\ bar'|'foo\\ bar'|
"foo\\\x bar\" df'a\ 'df'|"foo\\\x bar\"|df'a|\|'df'|
\"foo"|\|"foo"|
\"foo"\x|\|"foo"|\|x|
"foo\x"|"foo\x"|
"foo\ "|"foo\ "|
foo\ xx|foo|\|xx|
foo\ x\x|foo|\|x|\|x|
foo\ x\x\""|foo|\|x|\|x|\|""|
"foo\ x\x"|"foo\ x\x"|
"foo\ x\x\\"|"foo\ x\x\\"|
"foo\ x\x\\""foobar"|"foo\ x\x\\"|"foobar"|
"foo\ x\x\\"\''"foobar"|"foo\ x\x\\"|\|''|"foobar"|
"foo\ x\x\\"\'"fo'obar"|"foo\ x\x\\"|\|'"fo'|obar"|
"foo\ x\x\\"\'"fo'obar" 'don'\''t'|"foo\ x\x\\"|\|'"fo'|obar"|'don'|\|''|t'|
'foo\ bar'|'foo\ bar'|
'foo\\ bar'|'foo\\ bar'|
foo\ bar|foo|\|bar|
foo#bar\nbaz|foobaz|
:-) ;-)|:|-|)|;|-|)|
áéíóú|á|é|í|ó|ú|
"""
posix_data = r"""x|x|
foo bar|foo|bar|
foo bar|foo|bar|
foo bar |foo|bar|
foo bar bla fasel|foo|bar|bla|fasel|
x y z xxxx|x|y|z|xxxx|
\x bar|x|bar|
\ x bar| x|bar|
\ bar| bar|
foo \x bar|foo|x|bar|
foo \ x bar|foo| x|bar|
foo \ bar|foo| bar|
foo "bar" bla|foo|bar|bla|
"foo" "bar" "bla"|foo|bar|bla|
"foo" bar "bla"|foo|bar|bla|
"foo" bar bla|foo|bar|bla|
foo 'bar' bla|foo|bar|bla|
'foo' 'bar' 'bla'|foo|bar|bla|
'foo' bar 'bla'|foo|bar|bla|
'foo' bar bla|foo|bar|bla|
blurb foo"bar"bar"fasel" baz|blurb|foobarbarfasel|baz|
blurb foo'bar'bar'fasel' baz|blurb|foobarbarfasel|baz|
""||
''||
foo "" bar|foo||bar|
foo '' bar|foo||bar|
foo "" "" "" bar|foo||||bar|
foo '' '' '' bar|foo||||bar|
\"|"|
"\""|"|
"foo\ bar"|foo\ bar|
"foo\\ bar"|foo\ bar|
"foo\\ bar\""|foo\ bar"|
"foo\\" bar\"|foo\|bar"|
"foo\\ bar\" dfadf"|foo\ bar" dfadf|
"foo\\\ bar\" dfadf"|foo\\ bar" dfadf|
"foo\\\x bar\" dfadf"|foo\\x bar" dfadf|
"foo\x bar\" dfadf"|foo\x bar" dfadf|
\'|'|
'foo\ bar'|foo\ bar|
'foo\\ bar'|foo\\ bar|
"foo\\\x bar\" df'a\ 'df"|foo\\x bar" df'a\ 'df|
\"foo|"foo|
\"foo\x|"foox|
"foo\x"|foo\x|
"foo\ "|foo\ |
foo\ xx|foo xx|
foo\ x\x|foo xx|
foo\ x\x\"|foo xx"|
"foo\ x\x"|foo\ x\x|
"foo\ x\x\\"|foo\ x\x\|
"foo\ x\x\\""foobar"|foo\ x\x\foobar|
"foo\ x\x\\"\'"foobar"|foo\ x\x\'foobar|
"foo\ x\x\\"\'"fo'obar"|foo\ x\x\'fo'obar|
"foo\ x\x\\"\'"fo'obar" 'don'\''t'|foo\ x\x\'fo'obar|don't|
"foo\ x\x\\"\'"fo'obar" 'don'\''t' \\|foo\ x\x\'fo'obar|don't|\|
'foo\ bar'|foo\ bar|
'foo\\ bar'|foo\\ bar|
foo\ bar|foo bar|
foo#bar\nbaz|foo|baz|
:-) ;-)|:-)|;-)|
áéíóú|áéíóú|
"""
class ShlexTest(unittest.TestCase):
def setUp(self):
self.data = [x.split("|")[:-1]
for x in data.splitlines()]
self.posix_data = [x.split("|")[:-1]
for x in posix_data.splitlines()]
for item in self.data:
item[0] = item[0].replace(r"\n", "\n")
for item in self.posix_data:
item[0] = item[0].replace(r"\n", "\n")
def splitTest(self, data, comments):
for i in range(len(data)):
l = shlex.split(data[i][0], comments=comments)
self.assertEqual(l, data[i][1:],
"%s: %s != %s" %
(data[i][0], l, data[i][1:]))
def oldSplit(self, s):
ret = []
lex = shlex.shlex(StringIO(s))
tok = lex.get_token()
while tok:
ret.append(tok)
tok = lex.get_token()
return ret
def testSplitPosix(self):
"""Test data splitting with posix parser"""
self.splitTest(self.posix_data, comments=True)
def testCompat(self):
"""Test compatibility interface"""
for i in range(len(self.data)):
l = self.oldSplit(self.data[i][0])
self.assertEqual(l, self.data[i][1:],
"%s: %s != %s" %
(self.data[i][0], l, self.data[i][1:]))
# Allow this test to be used with old shlex.py
if not getattr(shlex, "split", None):
for methname in dir(ShlexTest):
if methname.startswith("test") and methname != "testCompat":
delattr(ShlexTest, methname)
def test_main():
test_support.run_unittest(ShlexTest)
if __name__ == "__main__":
test_main()
| gpl-3.0 |
kangfend/django | django/db/backends/oracle/creation.py | 8 | 14574 | import sys
import time
from django.conf import settings
from django.db.backends.base.creation import BaseDatabaseCreation
from django.db.utils import DatabaseError
from django.utils.six.moves import input
TEST_DATABASE_PREFIX = 'test_'
PASSWORD = 'Im_a_lumberjack'
class DatabaseCreation(BaseDatabaseCreation):
def _create_test_db(self, verbosity=1, autoclobber=False, keepdb=False):
parameters = self._get_test_db_params()
cursor = self.connection.cursor()
if self._test_database_create():
try:
self._execute_test_db_creation(cursor, parameters, verbosity)
except Exception as e:
# if we want to keep the db, then no need to do any of the below,
# just return and skip it all.
if keepdb:
return
sys.stderr.write("Got an error creating the test database: %s\n" % e)
if not autoclobber:
confirm = input(
"It appears the test database, %s, already exists. "
"Type 'yes' to delete it, or 'no' to cancel: " % parameters['user'])
if autoclobber or confirm == 'yes':
if verbosity >= 1:
print("Destroying old test database '%s'..." % self.connection.alias)
try:
self._execute_test_db_destruction(cursor, parameters, verbosity)
except DatabaseError as e:
if 'ORA-29857' in str(e):
self._handle_objects_preventing_db_destruction(cursor, parameters,
verbosity, autoclobber)
else:
# Ran into a database error that isn't about leftover objects in the tablespace
sys.stderr.write("Got an error destroying the old test database: %s\n" % e)
sys.exit(2)
except Exception as e:
sys.stderr.write("Got an error destroying the old test database: %s\n" % e)
sys.exit(2)
try:
self._execute_test_db_creation(cursor, parameters, verbosity)
except Exception as e:
sys.stderr.write("Got an error recreating the test database: %s\n" % e)
sys.exit(2)
else:
print("Tests cancelled.")
sys.exit(1)
if self._test_user_create():
if verbosity >= 1:
print("Creating test user...")
try:
self._create_test_user(cursor, parameters, verbosity)
except Exception as e:
sys.stderr.write("Got an error creating the test user: %s\n" % e)
if not autoclobber:
confirm = input(
"It appears the test user, %s, already exists. Type "
"'yes' to delete it, or 'no' to cancel: " % parameters['user'])
if autoclobber or confirm == 'yes':
try:
if verbosity >= 1:
print("Destroying old test user...")
self._destroy_test_user(cursor, parameters, verbosity)
if verbosity >= 1:
print("Creating test user...")
self._create_test_user(cursor, parameters, verbosity)
except Exception as e:
sys.stderr.write("Got an error recreating the test user: %s\n" % e)
sys.exit(2)
else:
print("Tests cancelled.")
sys.exit(1)
self.connection.close() # done with main user -- test user and tablespaces created
real_settings = settings.DATABASES[self.connection.alias]
real_settings['SAVED_USER'] = self.connection.settings_dict['SAVED_USER'] = \
self.connection.settings_dict['USER']
real_settings['SAVED_PASSWORD'] = self.connection.settings_dict['SAVED_PASSWORD'] = \
self.connection.settings_dict['PASSWORD']
real_test_settings = real_settings['TEST']
test_settings = self.connection.settings_dict['TEST']
real_test_settings['USER'] = real_settings['USER'] = test_settings['USER'] = \
self.connection.settings_dict['USER'] = parameters['user']
real_settings['PASSWORD'] = self.connection.settings_dict['PASSWORD'] = parameters['password']
return self.connection.settings_dict['NAME']
def set_as_test_mirror(self, primary_settings_dict):
"""
Set this database up to be used in testing as a mirror of a primary database
whose settings are given
"""
self.connection.settings_dict['USER'] = primary_settings_dict['USER']
self.connection.settings_dict['PASSWORD'] = primary_settings_dict['PASSWORD']
def _handle_objects_preventing_db_destruction(self, cursor, parameters, verbosity, autoclobber):
# There are objects in the test tablespace which prevent dropping it
# The easy fix is to drop the test user -- but are we allowed to do so?
print("There are objects in the old test database which prevent its destruction.")
print("If they belong to the test user, deleting the user will allow the test "
"database to be recreated.")
print("Otherwise, you will need to find and remove each of these objects, "
"or use a different tablespace.\n")
if self._test_user_create():
if not autoclobber:
confirm = input("Type 'yes' to delete user %s: " % parameters['user'])
if autoclobber or confirm == 'yes':
try:
if verbosity >= 1:
print("Destroying old test user...")
self._destroy_test_user(cursor, parameters, verbosity)
except Exception as e:
sys.stderr.write("Got an error destroying the test user: %s\n" % e)
sys.exit(2)
try:
if verbosity >= 1:
print("Destroying old test database '%s'..." % self.connection.alias)
self._execute_test_db_destruction(cursor, parameters, verbosity)
except Exception as e:
sys.stderr.write("Got an error destroying the test database: %s\n" % e)
sys.exit(2)
else:
print("Tests cancelled -- test database cannot be recreated.")
sys.exit(1)
else:
print("Django is configured to use pre-existing test user '%s',"
" and will not attempt to delete it.\n" % parameters['user'])
print("Tests cancelled -- test database cannot be recreated.")
sys.exit(1)
def _destroy_test_db(self, test_database_name, verbosity=1):
"""
Destroy a test database, prompting the user for confirmation if the
database already exists. Returns the name of the test database created.
"""
self.connection.settings_dict['USER'] = self.connection.settings_dict['SAVED_USER']
self.connection.settings_dict['PASSWORD'] = self.connection.settings_dict['SAVED_PASSWORD']
parameters = self._get_test_db_params()
cursor = self.connection.cursor()
time.sleep(1) # To avoid "database is being accessed by other users" errors.
if self._test_user_create():
if verbosity >= 1:
print('Destroying test user...')
self._destroy_test_user(cursor, parameters, verbosity)
if self._test_database_create():
if verbosity >= 1:
print('Destroying test database tables...')
self._execute_test_db_destruction(cursor, parameters, verbosity)
self.connection.close()
def _execute_test_db_creation(self, cursor, parameters, verbosity):
if verbosity >= 2:
print("_create_test_db(): dbname = %s" % parameters['user'])
statements = [
"""CREATE TABLESPACE %(tblspace)s
DATAFILE '%(datafile)s' SIZE 20M
REUSE AUTOEXTEND ON NEXT 10M MAXSIZE %(maxsize)s
""",
"""CREATE TEMPORARY TABLESPACE %(tblspace_temp)s
TEMPFILE '%(datafile_tmp)s' SIZE 20M
REUSE AUTOEXTEND ON NEXT 10M MAXSIZE %(maxsize_tmp)s
""",
]
self._execute_statements(cursor, statements, parameters, verbosity)
def _create_test_user(self, cursor, parameters, verbosity):
if verbosity >= 2:
print("_create_test_user(): username = %s" % parameters['user'])
statements = [
"""CREATE USER %(user)s
IDENTIFIED BY %(password)s
DEFAULT TABLESPACE %(tblspace)s
TEMPORARY TABLESPACE %(tblspace_temp)s
QUOTA UNLIMITED ON %(tblspace)s
""",
"""GRANT CREATE SESSION,
CREATE TABLE,
CREATE SEQUENCE,
CREATE PROCEDURE,
CREATE TRIGGER
TO %(user)s""",
]
self._execute_statements(cursor, statements, parameters, verbosity)
# Most test-suites can be run without the create-view privilege. But some need it.
extra = "GRANT CREATE VIEW TO %(user)s"
try:
self._execute_statements(cursor, [extra], parameters, verbosity, allow_quiet_fail=True)
except DatabaseError as err:
description = str(err)
if 'ORA-01031' in description:
if verbosity >= 2:
print("Failed to grant CREATE VIEW permission to test user. This may be ok.")
else:
raise
def _execute_test_db_destruction(self, cursor, parameters, verbosity):
if verbosity >= 2:
print("_execute_test_db_destruction(): dbname=%s" % parameters['user'])
statements = [
'DROP TABLESPACE %(tblspace)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS',
'DROP TABLESPACE %(tblspace_temp)s INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS',
]
self._execute_statements(cursor, statements, parameters, verbosity)
def _destroy_test_user(self, cursor, parameters, verbosity):
if verbosity >= 2:
print("_destroy_test_user(): user=%s" % parameters['user'])
print("Be patient. This can take some time...")
statements = [
'DROP USER %(user)s CASCADE',
]
self._execute_statements(cursor, statements, parameters, verbosity)
def _execute_statements(self, cursor, statements, parameters, verbosity, allow_quiet_fail=False):
for template in statements:
stmt = template % parameters
if verbosity >= 2:
print(stmt)
try:
cursor.execute(stmt)
except Exception as err:
if (not allow_quiet_fail) or verbosity >= 2:
sys.stderr.write("Failed (%s)\n" % (err))
raise
def _get_test_db_params(self):
return {
'dbname': self._test_database_name(),
'user': self._test_database_user(),
'password': self._test_database_passwd(),
'tblspace': self._test_database_tblspace(),
'tblspace_temp': self._test_database_tblspace_tmp(),
'datafile': self._test_database_tblspace_datafile(),
'datafile_tmp': self._test_database_tblspace_tmp_datafile(),
'maxsize': self._test_database_tblspace_size(),
'maxsize_tmp': self._test_database_tblspace_tmp_size(),
}
def _test_settings_get(self, key, default=None, prefixed=None):
"""
Return a value from the test settings dict,
or a given default,
or a prefixed entry from the main settings dict
"""
settings_dict = self.connection.settings_dict
val = settings_dict['TEST'].get(key, default)
if val is None:
val = TEST_DATABASE_PREFIX + settings_dict[prefixed]
return val
def _test_database_name(self):
return self._test_settings_get('NAME', prefixed='NAME')
def _test_database_create(self):
return self._test_settings_get('CREATE_DB', default=True)
def _test_user_create(self):
return self._test_settings_get('CREATE_USER', default=True)
def _test_database_user(self):
return self._test_settings_get('USER', prefixed='USER')
def _test_database_passwd(self):
return self._test_settings_get('PASSWORD', default=PASSWORD)
def _test_database_tblspace(self):
return self._test_settings_get('TBLSPACE', prefixed='USER')
def _test_database_tblspace_tmp(self):
settings_dict = self.connection.settings_dict
return settings_dict['TEST'].get('TBLSPACE_TMP',
TEST_DATABASE_PREFIX + settings_dict['USER'] + '_temp')
def _test_database_tblspace_datafile(self):
tblspace = '%s.dbf' % self._test_database_tblspace()
return self._test_settings_get('DATAFILE', default=tblspace)
def _test_database_tblspace_tmp_datafile(self):
tblspace = '%s.dbf' % self._test_database_tblspace_tmp()
return self._test_settings_get('DATAFILE_TMP', default=tblspace)
def _test_database_tblspace_size(self):
return self._test_settings_get('DATAFILE_MAXSIZE', default='500M')
def _test_database_tblspace_tmp_size(self):
return self._test_settings_get('DATAFILE_TMP_MAXSIZE', default='500M')
def _get_test_db_name(self):
"""
We need to return the 'production' DB name to get the test DB creation
machinery to work. This isn't a great deal in this case because DB
names as handled by Django haven't real counterparts in Oracle.
"""
return self.connection.settings_dict['NAME']
def test_db_signature(self):
settings_dict = self.connection.settings_dict
return (
settings_dict['HOST'],
settings_dict['PORT'],
settings_dict['ENGINE'],
settings_dict['NAME'],
self._test_database_user(),
)
| bsd-3-clause |
knagra/farnsworth | base/models.py | 1 | 5312 | '''
Project: Farnsworth
Author: Karandeep Singh Nagra
'''
from django.conf import settings
from django.contrib.auth.models import User, Group, Permission
from django.core.urlresolvers import reverse
from django.db import models
from phonenumber_field.modelfields import PhoneNumberField
from social.utils import setting_name
UID_LENGTH = getattr(settings, setting_name('UID_LENGTH'), 255)
def _get_user_view_url(user):
return reverse("member_profile", kwargs={"targetUsername": user.username})
User.get_view_url = _get_user_view_url
class UserProfile(models.Model):
'''
The UserProfile model. Tied to a unique User. Contains e-mail settings
and phone number.
'''
user = models.OneToOneField(User)
former_houses = models.CharField(
blank=True,
null=True,
max_length=100,
help_text="List of user's former BSC houses",
)
phone_number = PhoneNumberField(
null=True,
blank=True,
help_text="This should be of the form +1 (xxx) xxx-xxxx",
)
email_visible = models.BooleanField(
default=False,
help_text="Whether the email is visible in the directory",
)
phone_visible = models.BooleanField(
default=False,
help_text="Whether the phone number is visible in the directory",
)
RESIDENT = 'R'
BOARDER = 'B'
ALUMNUS = 'A'
STATUS_CHOICES = (
(RESIDENT, 'Current Resident'),
(BOARDER, 'Current Boarder'),
(ALUMNUS, 'Alumna/Alumnus'),
)
status = models.CharField(
max_length=1,
choices=STATUS_CHOICES,
default=RESIDENT,
help_text="Member status (resident, boarder, alumnus)",
)
email_announcement_notifications = models.BooleanField(
default=True,
help_text="Whether important manager announcements are e-mailed to you.",
)
email_request_notifications = models.BooleanField(
default=False,
help_text="Whether notifications are e-mailed to you about request updates.",
)
email_thread_notifications = models.BooleanField(
default=False,
help_text="Whether notifications are e-mailed to you about thread updates.",
)
email_workshift_notifications = models.BooleanField(
default=True,
help_text="Whether notifications are e-mailed to you about workshift updates.",
)
def __unicode__(self):
return self.user.get_full_name()
def get_email(self):
return self.user.email
def get_info(self):
return "{0.first_name} {0.last_name}".format(self.user)
def get_first(self):
return self.user.first_name
def get_last(self):
return self.user.last_name
def get_user(self):
return self.user.username
def get_full(self):
return self.get_info()
def is_userprofile(self):
return True
def get_view_url(self):
return _get_user_view_url(self.user)
class ProfileRequest(models.Model):
'''
The ProfileRequest model. A request to create a user account on the site.
'''
username = models.CharField(
blank=False,
null=True,
max_length=100,
help_text="Username if this user is created.",
)
first_name = models.CharField(
blank=False,
null=False,
max_length=100,
help_text="First name if user is created.",
)
last_name = models.CharField(
blank=False,
null=False,
max_length=100,
help_text="Last name if user is created.",
)
email = models.CharField(
blank=False,
null=False,
max_length=255,
help_text="E-mail address if user is created.",
)
request_date = models.DateTimeField(
auto_now_add=True,
help_text="Whether this request has been granted.",
)
affiliation = models.CharField(
max_length=1,
choices=UserProfile.STATUS_CHOICES,
default=UserProfile.RESIDENT,
help_text="User's affiliation with the house.",
)
password = models.CharField(
blank=True,
max_length=255,
help_text="User's password. Stored as hash",
)
provider = models.CharField(
blank=True,
max_length=32,
)
uid = models.CharField(
blank=True,
max_length=UID_LENGTH,
)
message = models.CharField(
blank=True,
max_length=255,
default="",
help_text="Details on how you're affiliated with us. Optional.",
)
def __unicode__(self):
return "Profile request for account '{0.first_name} {0.last_name} ({0.username})' on {0.request_date}".format(self)
def is_profilerequest(self):
return True
def create_user_profile(sender, instance, created, **kwargs):
'''
Function to add a user profile for every User that is created.
Parameters:
instance is an instance of User that was just saved.
'''
if created:
UserProfile.objects.create(user=instance)
# Connect signals with their respective functions from above.
# When a user is created, create a user profile associated with that user.
models.signals.post_save.connect(create_user_profile, sender=User)
| bsd-2-clause |
tecwebjoao/TecWeb-TF-2T-B-SI | venv/Lib/site-packages/pip/_vendor/colorama/win32.py | 535 | 5365 | # Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
# from winbase.h
STDOUT = -11
STDERR = -12
try:
import ctypes
from ctypes import LibraryLoader
windll = LibraryLoader(ctypes.WinDLL)
from ctypes import wintypes
except (AttributeError, ImportError):
windll = None
SetConsoleTextAttribute = lambda *_: None
winapi_test = lambda *_: None
else:
from ctypes import byref, Structure, c_char, POINTER
COORD = wintypes._COORD
class CONSOLE_SCREEN_BUFFER_INFO(Structure):
"""struct in wincon.h."""
_fields_ = [
("dwSize", COORD),
("dwCursorPosition", COORD),
("wAttributes", wintypes.WORD),
("srWindow", wintypes.SMALL_RECT),
("dwMaximumWindowSize", COORD),
]
def __str__(self):
return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
self.dwSize.Y, self.dwSize.X
, self.dwCursorPosition.Y, self.dwCursorPosition.X
, self.wAttributes
, self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
, self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
)
_GetStdHandle = windll.kernel32.GetStdHandle
_GetStdHandle.argtypes = [
wintypes.DWORD,
]
_GetStdHandle.restype = wintypes.HANDLE
_GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
_GetConsoleScreenBufferInfo.argtypes = [
wintypes.HANDLE,
POINTER(CONSOLE_SCREEN_BUFFER_INFO),
]
_GetConsoleScreenBufferInfo.restype = wintypes.BOOL
_SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
_SetConsoleTextAttribute.argtypes = [
wintypes.HANDLE,
wintypes.WORD,
]
_SetConsoleTextAttribute.restype = wintypes.BOOL
_SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
_SetConsoleCursorPosition.argtypes = [
wintypes.HANDLE,
COORD,
]
_SetConsoleCursorPosition.restype = wintypes.BOOL
_FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA
_FillConsoleOutputCharacterA.argtypes = [
wintypes.HANDLE,
c_char,
wintypes.DWORD,
COORD,
POINTER(wintypes.DWORD),
]
_FillConsoleOutputCharacterA.restype = wintypes.BOOL
_FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
_FillConsoleOutputAttribute.argtypes = [
wintypes.HANDLE,
wintypes.WORD,
wintypes.DWORD,
COORD,
POINTER(wintypes.DWORD),
]
_FillConsoleOutputAttribute.restype = wintypes.BOOL
_SetConsoleTitleW = windll.kernel32.SetConsoleTitleA
_SetConsoleTitleW.argtypes = [
wintypes.LPCSTR
]
_SetConsoleTitleW.restype = wintypes.BOOL
handles = {
STDOUT: _GetStdHandle(STDOUT),
STDERR: _GetStdHandle(STDERR),
}
def winapi_test():
handle = handles[STDOUT]
csbi = CONSOLE_SCREEN_BUFFER_INFO()
success = _GetConsoleScreenBufferInfo(
handle, byref(csbi))
return bool(success)
def GetConsoleScreenBufferInfo(stream_id=STDOUT):
handle = handles[stream_id]
csbi = CONSOLE_SCREEN_BUFFER_INFO()
success = _GetConsoleScreenBufferInfo(
handle, byref(csbi))
return csbi
def SetConsoleTextAttribute(stream_id, attrs):
handle = handles[stream_id]
return _SetConsoleTextAttribute(handle, attrs)
def SetConsoleCursorPosition(stream_id, position, adjust=True):
position = COORD(*position)
# If the position is out of range, do nothing.
if position.Y <= 0 or position.X <= 0:
return
# Adjust for Windows' SetConsoleCursorPosition:
# 1. being 0-based, while ANSI is 1-based.
# 2. expecting (x,y), while ANSI uses (y,x).
adjusted_position = COORD(position.Y - 1, position.X - 1)
if adjust:
# Adjust for viewport's scroll position
sr = GetConsoleScreenBufferInfo(STDOUT).srWindow
adjusted_position.Y += sr.Top
adjusted_position.X += sr.Left
# Resume normal processing
handle = handles[stream_id]
return _SetConsoleCursorPosition(handle, adjusted_position)
def FillConsoleOutputCharacter(stream_id, char, length, start):
handle = handles[stream_id]
char = c_char(char.encode())
length = wintypes.DWORD(length)
num_written = wintypes.DWORD(0)
# Note that this is hard-coded for ANSI (vs wide) bytes.
success = _FillConsoleOutputCharacterA(
handle, char, length, start, byref(num_written))
return num_written.value
def FillConsoleOutputAttribute(stream_id, attr, length, start):
''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
handle = handles[stream_id]
attribute = wintypes.WORD(attr)
length = wintypes.DWORD(length)
num_written = wintypes.DWORD(0)
# Note that this is hard-coded for ANSI (vs wide) bytes.
return _FillConsoleOutputAttribute(
handle, attribute, length, start, byref(num_written))
def SetConsoleTitle(title):
return _SetConsoleTitleW(title)
| apache-2.0 |
nrc/rustc-perf | collector/benchmarks/style-servo/components/script/dom/bindings/codegen/parser/tests/test_builtins.py | 276 | 1798 | import WebIDL
def WebIDLTest(parser, harness):
parser.parse("""
interface TestBuiltins {
attribute boolean b;
attribute byte s8;
attribute octet u8;
attribute short s16;
attribute unsigned short u16;
attribute long s32;
attribute unsigned long u32;
attribute long long s64;
attribute unsigned long long u64;
attribute DOMTimeStamp ts;
};
""")
results = parser.finish()
harness.ok(True, "TestBuiltins interface parsed without error.")
harness.check(len(results), 1, "Should be one production")
harness.ok(isinstance(results[0], WebIDL.IDLInterface),
"Should be an IDLInterface")
iface = results[0]
harness.check(iface.identifier.QName(), "::TestBuiltins", "Interface has the right QName")
harness.check(iface.identifier.name, "TestBuiltins", "Interface has the right name")
harness.check(iface.parent, None, "Interface has no parent")
members = iface.members
harness.check(len(members), 10, "Should be one production")
names = ["b", "s8", "u8", "s16", "u16", "s32", "u32", "s64", "u64", "ts"]
types = ["Boolean", "Byte", "Octet", "Short", "UnsignedShort", "Long", "UnsignedLong", "LongLong", "UnsignedLongLong", "UnsignedLongLong"]
for i in range(10):
attr = members[i]
harness.ok(isinstance(attr, WebIDL.IDLAttribute), "Should be an IDLAttribute")
harness.check(attr.identifier.QName(), "::TestBuiltins::" + names[i], "Attr has correct QName")
harness.check(attr.identifier.name, names[i], "Attr has correct name")
harness.check(str(attr.type), types[i], "Attr type is the correct name")
harness.ok(attr.type.isPrimitive(), "Should be a primitive type")
| mit |
kampanita/pelisalacarta | python/main-classic/servers/streaminto.py | 2 | 4141 | # -*- coding: utf-8 -*-
# ------------------------------------------------------------
# pelisalacarta - XBMC Plugin
# Conector para streaminto
# http://blog.tvalacarta.info/plugin-xbmc/pelisalacarta/
# ------------------------------------------------------------
import re
from core import logger
from core import scrapertools
def test_video_exists(page_url):
logger.info("[streamcloud.py] test_video_exists(page_url='%s')" % page_url)
data = scrapertools.cache_page(url=page_url)
if "File was deleted" in data:
return False, "El archivo no existe<br/>en streaminto o ha sido borrado."
elif "Video is processing now" in data:
return False, "El archivo está siendo procesado<br/>Prueba dentro de un rato."
else:
return True, ""
def get_video_url(page_url, premium=False, user="", password="", video_password=""):
logger.info("pelisalacarta.servers.streaminto url=" + page_url)
data = re.sub(r'\n|\t|\s+', '', scrapertools.cache_page(page_url))
video_urls = []
# {type:"html5",config:{file:'http://95.211.191.133:8777/3ki7frw76xuzcg3h5f6cbf7a34mbb2zr44g7sdojszegjqx5tdsaxgwr42vq/v.flv','provider':'http'}
media_url = scrapertools.get_match(data, """{type:"html5",config:{file:'([^']+)','provider':'http'}""")
video_urls.append([scrapertools.get_filename_from_url(media_url)[-4:] + " [streaminto]", media_url])
# streamer:"rtmp://95.211.191.133:1935/vod?h=3ki7frw76xuzcg3h5f6cbf7a34mbb2zr44g7sdojszegjqx5tdsaxgwr42vq"
rtmp_url = scrapertools.get_match(data, 'streamer:"([^"]+)"')
# ({file:"53/7269023927_n.flv?h=3ki7frw76xuzcg3h5f6cbf7a34mbb2zr44g7sdojszegjqx5tdsaxgwr42vq",
playpath = scrapertools.get_match(data, '\({file:"([^"]+)",')
swfUrl = "http://streamin.to/player/player.swf"
media_url = rtmp_url + " playpath=" + playpath + " swfUrl=" + swfUrl
video_urls.append(["RTMP [streaminto]", media_url])
for video_url in video_urls:
logger.info("pelisalacarta.servers.streaminto %s - %s" % (video_url[0], video_url[1]))
return video_urls
# Encuentra vídeos del servidor en el texto pasado
def find_videos(data):
# Añade manualmente algunos erróneos para evitarlos
encontrados = set()
encontrados.add("http://streamin.to/embed-theme.html")
encontrados.add("http://streamin.to/embed-jquery.html")
encontrados.add("http://streamin.to/embed-s.html")
encontrados.add("http://streamin.to/embed-images.html")
encontrados.add("http://streamin.to/embed-faq.html")
encontrados.add("http://streamin.to/embed-embed.html")
encontrados.add("http://streamin.to/embed-ri.html")
encontrados.add("http://streamin.to/embed-d.html")
encontrados.add("http://streamin.to/embed-css.html")
encontrados.add("http://streamin.to/embed-js.html")
encontrados.add("http://streamin.to/embed-player.html")
encontrados.add("http://streamin.to/embed-cgi.html")
devuelve = []
# http://streamin.to/z3nnqbspjyne
patronvideos = 'streamin.to/([a-z0-9A-Z]+)'
logger.info("pelisalacarta.servers.streaminto find_videos #" + patronvideos + "#")
matches = re.compile(patronvideos, re.DOTALL).findall(data)
for match in matches:
titulo = "[streaminto]"
url = "http://streamin.to/embed-" + match + ".html"
if url not in encontrados:
logger.info(" url=" + url)
devuelve.append([titulo, url, 'streaminto'])
encontrados.add(url)
else:
logger.info(" url duplicada=" + url)
# http://streamin.to/embed-z3nnqbspjyne.html
patronvideos = 'streamin.to/embed-([a-z0-9A-Z]+)'
logger.info("pelisalacarta.servers.streaminto find_videos #" + patronvideos + "#")
matches = re.compile(patronvideos, re.DOTALL).findall(data)
for match in matches:
titulo = "[streaminto]"
url = "http://streamin.to/embed-" + match + ".html"
if url not in encontrados:
logger.info(" url=" + url)
devuelve.append([titulo, url, 'streaminto'])
encontrados.add(url)
else:
logger.info(" url duplicada=" + url)
return devuelve
| gpl-3.0 |
beni55/edx-platform | common/djangoapps/student/migrations/0029_add_lookup_table_between_user_and_anonymous_student_id.py | 114 | 16366 | # -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'AnonymousUserId'
db.create_table('student_anonymoususerid', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'])),
('anonymous_user_id', self.gf('django.db.models.fields.CharField')(unique=True, max_length=16)),
('course_id', self.gf('django.db.models.fields.CharField')(max_length=255, db_index=True)),
))
db.send_create_signal('student', ['AnonymousUserId'])
def backwards(self, orm):
# Deleting model 'AnonymousUserId'
db.delete_table('student_anonymoususerid')
models = {
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
'auth.permission': {
'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'student.anonymoususerid': {
'Meta': {'object_name': 'AnonymousUserId'},
'anonymous_user_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '16'}),
'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
},
'student.courseenrollment': {
'Meta': {'ordering': "('user', 'course_id')", 'unique_together': "(('user', 'course_id'),)", 'object_name': 'CourseEnrollment'},
'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'mode': ('django.db.models.fields.CharField', [], {'default': "'honor'", 'max_length': '100'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
},
'student.courseenrollmentallowed': {
'Meta': {'unique_together': "(('email', 'course_id'),)", 'object_name': 'CourseEnrollmentAllowed'},
'auto_enroll': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'course_id': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'db_index': 'True', 'blank': 'True'}),
'email': ('django.db.models.fields.CharField', [], {'max_length': '255', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
},
'student.pendingemailchange': {
'Meta': {'object_name': 'PendingEmailChange'},
'activation_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'new_email': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True'})
},
'student.pendingnamechange': {
'Meta': {'object_name': 'PendingNameChange'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'new_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'rationale': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True'})
},
'student.registration': {
'Meta': {'object_name': 'Registration', 'db_table': "'auth_registration'"},
'activation_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '32', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'unique': 'True'})
},
'student.testcenterregistration': {
'Meta': {'object_name': 'TestCenterRegistration'},
'accommodation_code': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
'accommodation_request': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
'authorization_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'db_index': 'True'}),
'client_authorization_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '20', 'db_index': 'True'}),
'confirmed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
'course_id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'db_index': 'True'}),
'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
'eligibility_appointment_date_first': ('django.db.models.fields.DateField', [], {'db_index': 'True'}),
'eligibility_appointment_date_last': ('django.db.models.fields.DateField', [], {'db_index': 'True'}),
'exam_series_code': ('django.db.models.fields.CharField', [], {'max_length': '15', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'processed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
'testcenter_user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['student.TestCenterUser']"}),
'updated_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
'upload_error_message': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
'upload_status': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
'user_updated_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'})
},
'student.testcenteruser': {
'Meta': {'object_name': 'TestCenterUser'},
'address_1': ('django.db.models.fields.CharField', [], {'max_length': '40'}),
'address_2': ('django.db.models.fields.CharField', [], {'max_length': '40', 'blank': 'True'}),
'address_3': ('django.db.models.fields.CharField', [], {'max_length': '40', 'blank': 'True'}),
'candidate_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'db_index': 'True'}),
'city': ('django.db.models.fields.CharField', [], {'max_length': '32', 'db_index': 'True'}),
'client_candidate_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '50', 'db_index': 'True'}),
'company_name': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '50', 'blank': 'True'}),
'confirmed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
'country': ('django.db.models.fields.CharField', [], {'max_length': '3', 'db_index': 'True'}),
'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'db_index': 'True', 'blank': 'True'}),
'extension': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '8', 'blank': 'True'}),
'fax': ('django.db.models.fields.CharField', [], {'max_length': '35', 'blank': 'True'}),
'fax_country_code': ('django.db.models.fields.CharField', [], {'max_length': '3', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'db_index': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'db_index': 'True'}),
'middle_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'phone': ('django.db.models.fields.CharField', [], {'max_length': '35'}),
'phone_country_code': ('django.db.models.fields.CharField', [], {'max_length': '3', 'db_index': 'True'}),
'postal_code': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '16', 'blank': 'True'}),
'processed_at': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
'salutation': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'state': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
'suffix': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'updated_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'db_index': 'True', 'blank': 'True'}),
'upload_error_message': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
'upload_status': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '20', 'blank': 'True'}),
'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['auth.User']", 'unique': 'True'}),
'user_updated_at': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'})
},
'student.userprofile': {
'Meta': {'object_name': 'UserProfile', 'db_table': "'auth_userprofile'"},
'allow_certificate': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'courseware': ('django.db.models.fields.CharField', [], {'default': "'course.xml'", 'max_length': '255', 'blank': 'True'}),
'gender': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '6', 'null': 'True', 'blank': 'True'}),
'goals': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'language': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
'level_of_education': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '6', 'null': 'True', 'blank': 'True'}),
'location': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
'mailing_address': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'meta': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '255', 'blank': 'True'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'related_name': "'profile'", 'unique': 'True', 'to': "orm['auth.User']"}),
'year_of_birth': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'})
},
'student.userstanding': {
'Meta': {'object_name': 'UserStanding'},
'account_status': ('django.db.models.fields.CharField', [], {'max_length': '31', 'blank': 'True'}),
'changed_by': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'standing_last_changed_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'standing'", 'unique': 'True', 'to': "orm['auth.User']"})
},
'student.usertestgroup': {
'Meta': {'object_name': 'UserTestGroup'},
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '32', 'db_index': 'True'}),
'users': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.User']", 'db_index': 'True', 'symmetrical': 'False'})
}
}
complete_apps = ['student']
| agpl-3.0 |
317070/kaggle-heart | configurations/j6_sax_skew_zoom.py | 1 | 8970 | """Single slice vgg with normalised scale.
"""
import functools
import lasagne as nn
import numpy as np
import theano
import theano.tensor as T
import data_loader
import deep_learning_layers
import image_transform
import layers
import preprocess
import postprocess
import objectives
import theano_printer
import updates
import utils
# Random params
rng = np.random
take_a_dump = False # dump a lot of data in a pkl-dump file. (for debugging)
dump_network_loaded_data = False # dump the outputs from the dataloader (for debugging)
# Memory usage scheme
caching = None
# Save and validation frequency
validate_every = 10
validate_train_set = True
save_every = 10
restart_from_save = False
# Training (schedule) parameters
# - batch sizes
batch_size = 32
sunny_batch_size = 4
batches_per_chunk = 16
AV_SLICE_PER_PAT = 11
num_epochs_train = 80 * AV_SLICE_PER_PAT
# - learning rate and method
base_lr = .0001
learning_rate_schedule = {
0: base_lr,
num_epochs_train*9/10: base_lr/10,
}
momentum = 0.9
build_updates = updates.build_adam_updates
# Preprocessing stuff
cleaning_processes = [
preprocess.set_upside_up,]
cleaning_processes_post = [
functools.partial(preprocess.normalize_contrast_zmuv, z=2)]
augmentation_params = {
"rotate": (-180, 180),
"shear": (0, 0),
"zoom_x": (-0.5, 1.5),
"zoom_y": (-0.5, 1.5),
"skew_x": (-10, 10),
"skew_y": (-10, 10),
"translate": (-8, 8),
"flip_vert": (0, 1),
"roll_time": (0, 0),
"flip_time": (0, 0)
}
use_hough_roi = True # use roi to center patches
preprocess_train = functools.partial( # normscale_resize_and_augment has a bug
preprocess.preprocess_normscale,
normscale_resize_and_augment_function=functools.partial(
image_transform.normscale_resize_and_augment_2,
normalised_patch_size=(128,128)))
preprocess_validation = functools.partial(preprocess_train, augment=False)
preprocess_test = preprocess_train
sunny_preprocess_train = preprocess.sunny_preprocess_with_augmentation
sunny_preprocess_validation = preprocess.sunny_preprocess_validation
sunny_preprocess_test = preprocess.sunny_preprocess_validation
# Data generators
create_train_gen = data_loader.generate_train_batch
create_eval_valid_gen = functools.partial(data_loader.generate_validation_batch, set="validation")
create_eval_train_gen = functools.partial(data_loader.generate_validation_batch, set="train")
create_test_gen = functools.partial(data_loader.generate_test_batch, set=["validation", "test"])
# Input sizes
image_size = 64
data_sizes = {
"sliced:data:singleslice:difference:middle": (batch_size, 29, image_size, image_size), # 30 time steps, 30 mri_slices, 100 px wide, 100 px high,
"sliced:data:singleslice:difference": (batch_size, 29, image_size, image_size), # 30 time steps, 30 mri_slices, 100 px wide, 100 px high,
"sliced:data:singleslice": (batch_size, 30, image_size, image_size), # 30 time steps, 30 mri_slices, 100 px wide, 100 px high,
"sliced:data:ax": (batch_size, 30, 15, image_size, image_size), # 30 time steps, 30 mri_slices, 100 px wide, 100 px high,
"sliced:data:shape": (batch_size, 2,),
"sunny": (sunny_batch_size, 1, image_size, image_size)
# TBC with the metadata
}
# Objective
l2_weight = 0.000
l2_weight_out = 0.000
def build_objective(interface_layers):
# l2 regu on certain layers
l2_penalty = nn.regularization.regularize_layer_params_weighted(
interface_layers["regularizable"], nn.regularization.l2)
# build objective
return objectives.KaggleObjective(interface_layers["outputs"], penalty=l2_penalty)
# Testing
postprocess = postprocess.postprocess
test_time_augmentations = 20 * AV_SLICE_PER_PAT # More augmentations since a we only use single slices
tta_average_method = lambda x: np.cumsum(utils.norm_geometric_average(utils.cdf_to_pdf(x)))
# Architecture
def build_model(input_layer = None):
#################
# Regular model #
#################
input_size = data_sizes["sliced:data:singleslice"]
if input_layer:
l0 = input_layer
else:
l0 = nn.layers.InputLayer(input_size)
l1a = nn.layers.dnn.Conv2DDNNLayer(l0, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1b = nn.layers.dnn.Conv2DDNNLayer(l1a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=64, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l1 = nn.layers.dnn.MaxPool2DDNNLayer(l1b, pool_size=(2,2), stride=(2,2))
l2a = nn.layers.dnn.Conv2DDNNLayer(l1, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2b = nn.layers.dnn.Conv2DDNNLayer(l2a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=128, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l2 = nn.layers.dnn.MaxPool2DDNNLayer(l2b, pool_size=(2,2), stride=(2,2))
l3a = nn.layers.dnn.Conv2DDNNLayer(l2, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=256, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3b = nn.layers.dnn.Conv2DDNNLayer(l3a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=256, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3c = nn.layers.dnn.Conv2DDNNLayer(l3b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=256, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l3 = nn.layers.dnn.MaxPool2DDNNLayer(l3c, pool_size=(2,2), stride=(2,2))
l4a = nn.layers.dnn.Conv2DDNNLayer(l3, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4b = nn.layers.dnn.Conv2DDNNLayer(l4a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4c = nn.layers.dnn.Conv2DDNNLayer(l4b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l4 = nn.layers.dnn.MaxPool2DDNNLayer(l4c, pool_size=(2,2), stride=(2,2))
l5a = nn.layers.dnn.Conv2DDNNLayer(l4, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5b = nn.layers.dnn.Conv2DDNNLayer(l5a, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5c = nn.layers.dnn.Conv2DDNNLayer(l5b, W=nn.init.Orthogonal("relu"), filter_size=(3,3), num_filters=512, stride=(1,1), pad="same", nonlinearity=nn.nonlinearities.rectify)
l5 = nn.layers.dnn.MaxPool2DDNNLayer(l5c, pool_size=(2,2), stride=(2,2))
# Systole Dense layers
ldsys1 = nn.layers.DenseLayer(l5, num_units=512, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
ldsys1drop = nn.layers.dropout(ldsys1, p=0.5)
ldsys2 = nn.layers.DenseLayer(ldsys1drop, num_units=512, W=nn.init.Orthogonal("relu"),b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
ldsys2drop = nn.layers.dropout(ldsys2, p=0.5)
ldsys3 = nn.layers.DenseLayer(ldsys2drop, num_units=600, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.softmax)
ldsys3drop = nn.layers.dropout(ldsys3, p=0.5) # dropout at the output might encourage adjacent neurons to correllate
ldsys3dropnorm = layers.NormalisationLayer(ldsys3drop)
l_systole = layers.CumSumLayer(ldsys3dropnorm)
# Diastole Dense layers
lddia1 = nn.layers.DenseLayer(l5, num_units=512, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
lddia1drop = nn.layers.dropout(lddia1, p=0.5)
lddia2 = nn.layers.DenseLayer(lddia1drop, num_units=512, W=nn.init.Orthogonal("relu"),b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.rectify)
lddia2drop = nn.layers.dropout(lddia2, p=0.5)
lddia3 = nn.layers.DenseLayer(lddia2drop, num_units=600, W=nn.init.Orthogonal("relu"), b=nn.init.Constant(0.1), nonlinearity=nn.nonlinearities.softmax)
lddia3drop = nn.layers.dropout(lddia3, p=0.5) # dropout at the output might encourage adjacent neurons to correllate
lddia3dropnorm = layers.NormalisationLayer(lddia3drop)
l_diastole = layers.CumSumLayer(lddia3dropnorm)
return {
"inputs":{
"sliced:data:singleslice": l0
},
"outputs": {
"systole": l_systole,
"diastole": l_diastole,
},
"regularizable": {
ldsys1: l2_weight,
ldsys2: l2_weight,
ldsys3: l2_weight_out,
lddia1: l2_weight,
lddia2: l2_weight,
lddia3: l2_weight_out,
},
"meta_outputs": {
"systole": ldsys2,
"diastole": lddia2,
}
}
| mit |
prestapyt/prestapyt | prestapyt/xml2dict.py | 1 | 4814 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Code from https://github.com/nkchenz/lhammer/blob/master/lhammer/xml2dict.py
Distributed under GPL2 Licence
CopyRight (C) 2009 Chen Zheng
Adapted for Prestapyt by Guewen Baconnier
Copyright 2012 Camptocamp SA
"""
import re
try:
import xml.etree.cElementTree as ET
except ImportError as err:
import xml.etree.ElementTree as ET
def _parse_node(node):
tree = {}
attrs = {}
for attr_tag, attr_value in node.attrib.items():
# skip href attributes, not supported when converting to dict
if attr_tag == '{http://www.w3.org/1999/xlink}href':
continue
attrs.update(_make_dict(attr_tag, attr_value))
value = node.text.strip() if node.text is not None else ''
if attrs:
tree['attrs'] = attrs
#Save childrens
has_child = False
for child in node.getchildren():
has_child = True
ctag = child.tag
ctree = _parse_node(child)
cdict = _make_dict(ctag, ctree)
# no value when there is child elements
if ctree:
value = ''
# first time an attribute is found
if ctag not in tree: # First time found
tree.update(cdict)
continue
# many times the same attribute, we change to a list
old = tree[ctag]
if not isinstance(old, list):
tree[ctag] = [old] # change to list
tree[ctag].append(ctree) # Add new entry
if not has_child:
tree['value'] = value
# if there is only a value; no attribute, no child, we return directly the value
if list(tree.keys()) == ['value']:
tree = tree['value']
return tree
def _make_dict(tag, value):
"""Generate a new dict with tag and value
If tag is like '{http://cs.sfsu.edu/csc867/myscheduler}patients',
split it first to: http://cs.sfsu.edu/csc867/myscheduler, patients
"""
tag_values = value
result = re.compile("\{(.*)\}(.*)").search(tag)
if result:
tag_values = {'value': value}
tag_values['xmlns'], tag = result.groups() # We have a namespace!
return {tag: tag_values}
def xml2dict(xml):
"""Parse xml string to dict"""
element_tree = ET.fromstring(xml)
return ET2dict(element_tree)
def ET2dict(element_tree):
"""Parse xml string to dict"""
return _make_dict(element_tree.tag, _parse_node(element_tree))
if __name__ == '__main__':
from pprint import pprint
s = """<?xml version="1.0" encoding="UTF-8"?>
<prestashop xmlns:xlink="http://www.w3.org/1999/xlink">
<addresses>
<address id="1" xlink:href="http://localhost:8080/api/addresses/1"/>
<address id="2" xlink:href="http://localhost:8080/api/addresses/2"/>
<address id="3" xlink:href="http://localhost:8080/api/addresses/3"/>
<address id="4" xlink:href="http://localhost:8080/api/addresses/4"/>
<address id="5" xlink:href="http://localhost:8080/api/addresses/5"/>
<address id="6" xlink:href="http://localhost:8080/api/addresses/6"/>
<address id="7" xlink:href="http://localhost:8080/api/addresses/7"/>
<address id="8" xlink:href="http://localhost:8080/api/addresses/8"/>
</addresses>
</prestashop>"""
pprint(xml2dict(s))
s = """<?xml version="1.0" encoding="UTF-8"?>
<prestashop xmlns:xlink="http://www.w3.org/1999/xlink">
<address>
<id><![CDATA[1]]></id>
<id_customer></id_customer>
<id_manufacturer xlink:href="http://localhost:8080/api/manufacturers/1"><![CDATA[1]]></id_manufacturer>
<id_supplier></id_supplier>
<id_country xlink:href="http://localhost:8080/api/countries/21"><![CDATA[21]]></id_country>
<id_state xlink:href="http://localhost:8080/api/states/5"><![CDATA[5]]></id_state>
<alias><![CDATA[manufacturer]]></alias>
<company></company>
<lastname><![CDATA[JOBS]]></lastname>
<firstname><![CDATA[STEVEN]]></firstname>
<address1><![CDATA[1 Infinite Loop]]></address1>
<address2></address2>
<postcode><![CDATA[95014]]></postcode>
<city><![CDATA[Cupertino]]></city>
<other></other>
<phone><![CDATA[(800) 275-2273]]></phone>
<phone_mobile></phone_mobile>
<dni></dni>
<vat_number></vat_number>
<deleted><![CDATA[0]]></deleted>
<date_add><![CDATA[2012-02-06 09:33:52]]></date_add>
<date_upd><![CDATA[2012-02-07 11:18:48]]></date_upd>
</address>
</prestashop>"""
pprint(xml2dict(s))
from . import dict2xml
from .prestapyt import PrestaShopWebService
prestashop = PrestaShopWebService('http://localhost:8080/api',
'BVWPFFYBT97WKM959D7AVVD0M4815Y1L')
products_xml = prestashop.get('products', 1)
products_dict = ET2dict(products_xml)
pprint(dict2xml.dict2xml(products_dict))
| agpl-3.0 |
ashutrix03/inteygrate_flaskapp-master | dateutil/parser.py | 49 | 50234 | # -*- coding:iso-8859-1 -*-
"""
This module offers a generic date/time string parser which is able to parse
most known formats to represent a date and/or time.
This module attempts to be forgiving with regards to unlikely input formats,
returning a datetime object even for dates which are ambiguous. If an element
of a date/time stamp is omitted, the following rules are applied:
- If AM or PM is left unspecified, a 24-hour clock is assumed, however, an hour
on a 12-hour clock (``0 <= hour <= 12``) *must* be specified if AM or PM is
specified.
- If a time zone is omitted, a timezone-naive datetime is returned.
If any other elements are missing, they are taken from the
:class:`datetime.datetime` object passed to the parameter ``default``. If this
results in a day number exceeding the valid number of days per month, the
value falls back to the end of the month.
Additional resources about date/time string formats can be found below:
- `A summary of the international standard date and time notation
<http://www.cl.cam.ac.uk/~mgk25/iso-time.html>`_
- `W3C Date and Time Formats <http://www.w3.org/TR/NOTE-datetime>`_
- `Time Formats (Planetary Rings Node) <http://pds-rings.seti.org/tools/time_formats.html>`_
- `CPAN ParseDate module
<http://search.cpan.org/~muir/Time-modules-2013.0912/lib/Time/ParseDate.pm>`_
- `Java SimpleDateFormat Class
<https://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html>`_
"""
from __future__ import unicode_literals
import datetime
import string
import time
import collections
import re
from io import StringIO
from calendar import monthrange, isleap
from six import text_type, binary_type, integer_types
from . import relativedelta
from . import tz
__all__ = ["parse", "parserinfo"]
class _timelex(object):
# Fractional seconds are sometimes split by a comma
_split_decimal = re.compile("([\.,])")
def __init__(self, instream):
if isinstance(instream, binary_type):
instream = instream.decode()
if isinstance(instream, text_type):
instream = StringIO(instream)
if getattr(instream, 'read', None) is None:
raise TypeError('Parser must be a string or character stream, not '
'{itype}'.format(itype=instream.__class__.__name__))
self.instream = instream
self.charstack = []
self.tokenstack = []
self.eof = False
def get_token(self):
"""
This function breaks the time string into lexical units (tokens), which
can be parsed by the parser. Lexical units are demarcated by changes in
the character set, so any continuous string of letters is considered
one unit, any continuous string of numbers is considered one unit.
The main complication arises from the fact that dots ('.') can be used
both as separators (e.g. "Sep.20.2009") or decimal points (e.g.
"4:30:21.447"). As such, it is necessary to read the full context of
any dot-separated strings before breaking it into tokens; as such, this
function maintains a "token stack", for when the ambiguous context
demands that multiple tokens be parsed at once.
"""
if self.tokenstack:
return self.tokenstack.pop(0)
seenletters = False
token = None
state = None
while not self.eof:
# We only realize that we've reached the end of a token when we
# find a character that's not part of the current token - since
# that character may be part of the next token, it's stored in the
# charstack.
if self.charstack:
nextchar = self.charstack.pop(0)
else:
nextchar = self.instream.read(1)
while nextchar == '\x00':
nextchar = self.instream.read(1)
if not nextchar:
self.eof = True
break
elif not state:
# First character of the token - determines if we're starting
# to parse a word, a number or something else.
token = nextchar
if self.isword(nextchar):
state = 'a'
elif self.isnum(nextchar):
state = '0'
elif self.isspace(nextchar):
token = ' '
break # emit token
else:
break # emit token
elif state == 'a':
# If we've already started reading a word, we keep reading
# letters until we find something that's not part of a word.
seenletters = True
if self.isword(nextchar):
token += nextchar
elif nextchar == '.':
token += nextchar
state = 'a.'
else:
self.charstack.append(nextchar)
break # emit token
elif state == '0':
# If we've already started reading a number, we keep reading
# numbers until we find something that doesn't fit.
if self.isnum(nextchar):
token += nextchar
elif nextchar == '.' or (nextchar == ',' and len(token) >= 2):
token += nextchar
state = '0.'
else:
self.charstack.append(nextchar)
break # emit token
elif state == 'a.':
# If we've seen some letters and a dot separator, continue
# parsing, and the tokens will be broken up later.
seenletters = True
if nextchar == '.' or self.isword(nextchar):
token += nextchar
elif self.isnum(nextchar) and token[-1] == '.':
token += nextchar
state = '0.'
else:
self.charstack.append(nextchar)
break # emit token
elif state == '0.':
# If we've seen at least one dot separator, keep going, we'll
# break up the tokens later.
if nextchar == '.' or self.isnum(nextchar):
token += nextchar
elif self.isword(nextchar) and token[-1] == '.':
token += nextchar
state = 'a.'
else:
self.charstack.append(nextchar)
break # emit token
if (state in ('a.', '0.') and (seenletters or token.count('.') > 1 or
token[-1] in '.,')):
l = self._split_decimal.split(token)
token = l[0]
for tok in l[1:]:
if tok:
self.tokenstack.append(tok)
if state == '0.' and token.count('.') == 0:
token = token.replace(',', '.')
return token
def __iter__(self):
return self
def __next__(self):
token = self.get_token()
if token is None:
raise StopIteration
return token
def next(self):
return self.__next__() # Python 2.x support
@classmethod
def split(cls, s):
return list(cls(s))
@classmethod
def isword(cls, nextchar):
""" Whether or not the next character is part of a word """
return nextchar.isalpha()
@classmethod
def isnum(cls, nextchar):
""" Whether the next character is part of a number """
return nextchar.isdigit()
@classmethod
def isspace(cls, nextchar):
""" Whether the next character is whitespace """
return nextchar.isspace()
class _resultbase(object):
def __init__(self):
for attr in self.__slots__:
setattr(self, attr, None)
def _repr(self, classname):
l = []
for attr in self.__slots__:
value = getattr(self, attr)
if value is not None:
l.append("%s=%s" % (attr, repr(value)))
return "%s(%s)" % (classname, ", ".join(l))
def __len__(self):
return (sum(getattr(self, attr) is not None
for attr in self.__slots__))
def __repr__(self):
return self._repr(self.__class__.__name__)
class parserinfo(object):
"""
Class which handles what inputs are accepted. Subclass this to customize
the language and acceptable values for each parameter.
:param dayfirst:
Whether to interpret the first value in an ambiguous 3-integer date
(e.g. 01/05/09) as the day (``True``) or month (``False``). If
``yearfirst`` is set to ``True``, this distinguishes between YDM
and YMD. Default is ``False``.
:param yearfirst:
Whether to interpret the first value in an ambiguous 3-integer date
(e.g. 01/05/09) as the year. If ``True``, the first number is taken
to be the year, otherwise the last number is taken to be the year.
Default is ``False``.
"""
# m from a.m/p.m, t from ISO T separator
JUMP = [" ", ".", ",", ";", "-", "/", "'",
"at", "on", "and", "ad", "m", "t", "of",
"st", "nd", "rd", "th"]
WEEKDAYS = [("Mon", "Monday"),
("Tue", "Tuesday"),
("Wed", "Wednesday"),
("Thu", "Thursday"),
("Fri", "Friday"),
("Sat", "Saturday"),
("Sun", "Sunday")]
MONTHS = [("Jan", "January"),
("Feb", "February"),
("Mar", "March"),
("Apr", "April"),
("May", "May"),
("Jun", "June"),
("Jul", "July"),
("Aug", "August"),
("Sep", "Sept", "September"),
("Oct", "October"),
("Nov", "November"),
("Dec", "December")]
HMS = [("h", "hour", "hours"),
("m", "minute", "minutes"),
("s", "second", "seconds")]
AMPM = [("am", "a"),
("pm", "p")]
UTCZONE = ["UTC", "GMT", "Z"]
PERTAIN = ["of"]
TZOFFSET = {}
def __init__(self, dayfirst=False, yearfirst=False):
self._jump = self._convert(self.JUMP)
self._weekdays = self._convert(self.WEEKDAYS)
self._months = self._convert(self.MONTHS)
self._hms = self._convert(self.HMS)
self._ampm = self._convert(self.AMPM)
self._utczone = self._convert(self.UTCZONE)
self._pertain = self._convert(self.PERTAIN)
self.dayfirst = dayfirst
self.yearfirst = yearfirst
self._year = time.localtime().tm_year
self._century = self._year // 100 * 100
def _convert(self, lst):
dct = {}
for i, v in enumerate(lst):
if isinstance(v, tuple):
for v in v:
dct[v.lower()] = i
else:
dct[v.lower()] = i
return dct
def jump(self, name):
return name.lower() in self._jump
def weekday(self, name):
if len(name) >= 3:
try:
return self._weekdays[name.lower()]
except KeyError:
pass
return None
def month(self, name):
if len(name) >= 3:
try:
return self._months[name.lower()] + 1
except KeyError:
pass
return None
def hms(self, name):
try:
return self._hms[name.lower()]
except KeyError:
return None
def ampm(self, name):
try:
return self._ampm[name.lower()]
except KeyError:
return None
def pertain(self, name):
return name.lower() in self._pertain
def utczone(self, name):
return name.lower() in self._utczone
def tzoffset(self, name):
if name in self._utczone:
return 0
return self.TZOFFSET.get(name)
def convertyear(self, year, century_specified=False):
if year < 100 and not century_specified:
year += self._century
if abs(year - self._year) >= 50:
if year < self._year:
year += 100
else:
year -= 100
return year
def validate(self, res):
# move to info
if res.year is not None:
res.year = self.convertyear(res.year, res.century_specified)
if res.tzoffset == 0 and not res.tzname or res.tzname == 'Z':
res.tzname = "UTC"
res.tzoffset = 0
elif res.tzoffset != 0 and res.tzname and self.utczone(res.tzname):
res.tzoffset = 0
return True
class _ymd(list):
def __init__(self, tzstr, *args, **kwargs):
super(self.__class__, self).__init__(*args, **kwargs)
self.century_specified = False
self.tzstr = tzstr
@staticmethod
def token_could_be_year(token, year):
try:
return int(token) == year
except ValueError:
return False
@staticmethod
def find_potential_year_tokens(year, tokens):
return [token for token in tokens if _ymd.token_could_be_year(token, year)]
def find_probable_year_index(self, tokens):
"""
attempt to deduce if a pre 100 year was lost
due to padded zeros being taken off
"""
for index, token in enumerate(self):
potential_year_tokens = _ymd.find_potential_year_tokens(token, tokens)
if len(potential_year_tokens) == 1 and len(potential_year_tokens[0]) > 2:
return index
def append(self, val):
if hasattr(val, '__len__'):
if val.isdigit() and len(val) > 2:
self.century_specified = True
elif val > 100:
self.century_specified = True
super(self.__class__, self).append(int(val))
def resolve_ymd(self, mstridx, yearfirst, dayfirst):
len_ymd = len(self)
year, month, day = (None, None, None)
if len_ymd > 3:
raise ValueError("More than three YMD values")
elif len_ymd == 1 or (mstridx != -1 and len_ymd == 2):
# One member, or two members with a month string
if mstridx != -1:
month = self[mstridx]
del self[mstridx]
if len_ymd > 1 or mstridx == -1:
if self[0] > 31:
year = self[0]
else:
day = self[0]
elif len_ymd == 2:
# Two members with numbers
if self[0] > 31:
# 99-01
year, month = self
elif self[1] > 31:
# 01-99
month, year = self
elif dayfirst and self[1] <= 12:
# 13-01
day, month = self
else:
# 01-13
month, day = self
elif len_ymd == 3:
# Three members
if mstridx == 0:
month, day, year = self
elif mstridx == 1:
if self[0] > 31 or (yearfirst and self[2] <= 31):
# 99-Jan-01
year, month, day = self
else:
# 01-Jan-01
# Give precendence to day-first, since
# two-digit years is usually hand-written.
day, month, year = self
elif mstridx == 2:
# WTF!?
if self[1] > 31:
# 01-99-Jan
day, year, month = self
else:
# 99-01-Jan
year, day, month = self
else:
if self[0] > 31 or \
self.find_probable_year_index(_timelex.split(self.tzstr)) == 0 or \
(yearfirst and self[1] <= 12 and self[2] <= 31):
# 99-01-01
if dayfirst and self[2] <= 12:
year, day, month = self
else:
year, month, day = self
elif self[0] > 12 or (dayfirst and self[1] <= 12):
# 13-01-01
day, month, year = self
else:
# 01-13-01
month, day, year = self
return year, month, day
class parser(object):
def __init__(self, info=None):
self.info = info or parserinfo()
def parse(self, timestr, default=None, ignoretz=False, tzinfos=None, **kwargs):
"""
Parse the date/time string into a :class:`datetime.datetime` object.
:param timestr:
Any date/time string using the supported formats.
:param default:
The default datetime object, if this is a datetime object and not
``None``, elements specified in ``timestr`` replace elements in the
default object.
:param ignoretz:
If set ``True``, time zones in parsed strings are ignored and a
naive :class:`datetime.datetime` object is returned.
:param tzinfos:
Additional time zone names / aliases which may be present in the
string. This argument maps time zone names (and optionally offsets
from those time zones) to time zones. This parameter can be a
dictionary with timezone aliases mapping time zone names to time
zones or a function taking two parameters (``tzname`` and
``tzoffset``) and returning a time zone.
The timezones to which the names are mapped can be an integer
offset from UTC in minutes or a :class:`tzinfo` object.
.. doctest::
:options: +NORMALIZE_WHITESPACE
>>> from dateutil.parser import parse
>>> from dateutil.tz import gettz
>>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
>>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
>>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
datetime.datetime(2012, 1, 19, 17, 21,
tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))
This parameter is ignored if ``ignoretz`` is set.
:param **kwargs:
Keyword arguments as passed to ``_parse()``.
:return:
Returns a :class:`datetime.datetime` object or, if the
``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
first element being a :class:`datetime.datetime` object, the second
a tuple containing the fuzzy tokens.
:raises ValueError:
Raised for invalid or unknown string format, if the provided
:class:`tzinfo` is not in a valid format, or if an invalid date
would be created.
:raises OverflowError:
Raised if the parsed date exceeds the largest valid C integer on
your system.
"""
if default is None:
effective_dt = datetime.datetime.now()
default = datetime.datetime.now().replace(hour=0, minute=0,
second=0, microsecond=0)
else:
effective_dt = default
res, skipped_tokens = self._parse(timestr, **kwargs)
if res is None:
raise ValueError("Unknown string format")
if len(res) == 0:
raise ValueError("String does not contain a date.")
repl = {}
for attr in ("year", "month", "day", "hour",
"minute", "second", "microsecond"):
value = getattr(res, attr)
if value is not None:
repl[attr] = value
if 'day' not in repl:
# If the default day exceeds the last day of the month, fall back to
# the end of the month.
cyear = default.year if res.year is None else res.year
cmonth = default.month if res.month is None else res.month
cday = default.day if res.day is None else res.day
if cday > monthrange(cyear, cmonth)[1]:
repl['day'] = monthrange(cyear, cmonth)[1]
ret = default.replace(**repl)
if res.weekday is not None and not res.day:
ret = ret+relativedelta.relativedelta(weekday=res.weekday)
if not ignoretz:
if (isinstance(tzinfos, collections.Callable) or
tzinfos and res.tzname in tzinfos):
if isinstance(tzinfos, collections.Callable):
tzdata = tzinfos(res.tzname, res.tzoffset)
else:
tzdata = tzinfos.get(res.tzname)
if isinstance(tzdata, datetime.tzinfo):
tzinfo = tzdata
elif isinstance(tzdata, text_type):
tzinfo = tz.tzstr(tzdata)
elif isinstance(tzdata, integer_types):
tzinfo = tz.tzoffset(res.tzname, tzdata)
else:
raise ValueError("Offset must be tzinfo subclass, "
"tz string, or int offset.")
ret = ret.replace(tzinfo=tzinfo)
elif res.tzname and res.tzname in time.tzname:
ret = ret.replace(tzinfo=tz.tzlocal())
elif res.tzoffset == 0:
ret = ret.replace(tzinfo=tz.tzutc())
elif res.tzoffset:
ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
if kwargs.get('fuzzy_with_tokens', False):
return ret, skipped_tokens
else:
return ret
class _result(_resultbase):
__slots__ = ["year", "month", "day", "weekday",
"hour", "minute", "second", "microsecond",
"tzname", "tzoffset", "ampm"]
def _parse(self, timestr, dayfirst=None, yearfirst=None, fuzzy=False,
fuzzy_with_tokens=False):
"""
Private method which performs the heavy lifting of parsing, called from
``parse()``, which passes on its ``kwargs`` to this function.
:param timestr:
The string to parse.
:param dayfirst:
Whether to interpret the first value in an ambiguous 3-integer date
(e.g. 01/05/09) as the day (``True``) or month (``False``). If
``yearfirst`` is set to ``True``, this distinguishes between YDM
and YMD. If set to ``None``, this value is retrieved from the
current :class:`parserinfo` object (which itself defaults to
``False``).
:param yearfirst:
Whether to interpret the first value in an ambiguous 3-integer date
(e.g. 01/05/09) as the year. If ``True``, the first number is taken
to be the year, otherwise the last number is taken to be the year.
If this is set to ``None``, the value is retrieved from the current
:class:`parserinfo` object (which itself defaults to ``False``).
:param fuzzy:
Whether to allow fuzzy parsing, allowing for string like "Today is
January 1, 2047 at 8:21:00AM".
:param fuzzy_with_tokens:
If ``True``, ``fuzzy`` is automatically set to True, and the parser
will return a tuple where the first element is the parsed
:class:`datetime.datetime` datetimestamp and the second element is
a tuple containing the portions of the string which were ignored:
.. doctest::
>>> from dateutil.parser import parse
>>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
(datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))
"""
if fuzzy_with_tokens:
fuzzy = True
info = self.info
if dayfirst is None:
dayfirst = info.dayfirst
if yearfirst is None:
yearfirst = info.yearfirst
res = self._result()
l = _timelex.split(timestr) # Splits the timestr into tokens
# keep up with the last token skipped so we can recombine
# consecutively skipped tokens (-2 for when i begins at 0).
last_skipped_token_i = -2
skipped_tokens = list()
try:
# year/month/day list
ymd = _ymd(timestr)
# Index of the month string in ymd
mstridx = -1
len_l = len(l)
i = 0
while i < len_l:
# Check if it's a number
try:
value_repr = l[i]
value = float(value_repr)
except ValueError:
value = None
if value is not None:
# Token is a number
len_li = len(l[i])
i += 1
if (len(ymd) == 3 and len_li in (2, 4)
and res.hour is None and (i >= len_l or (l[i] != ':' and
info.hms(l[i]) is None))):
# 19990101T23[59]
s = l[i-1]
res.hour = int(s[:2])
if len_li == 4:
res.minute = int(s[2:])
elif len_li == 6 or (len_li > 6 and l[i-1].find('.') == 6):
# YYMMDD or HHMMSS[.ss]
s = l[i-1]
if not ymd and l[i-1].find('.') == -1:
#ymd.append(info.convertyear(int(s[:2])))
ymd.append(s[:2])
ymd.append(s[2:4])
ymd.append(s[4:])
else:
# 19990101T235959[.59]
res.hour = int(s[:2])
res.minute = int(s[2:4])
res.second, res.microsecond = _parsems(s[4:])
elif len_li in (8, 12, 14):
# YYYYMMDD
s = l[i-1]
ymd.append(s[:4])
ymd.append(s[4:6])
ymd.append(s[6:8])
if len_li > 8:
res.hour = int(s[8:10])
res.minute = int(s[10:12])
if len_li > 12:
res.second = int(s[12:])
elif ((i < len_l and info.hms(l[i]) is not None) or
(i+1 < len_l and l[i] == ' ' and
info.hms(l[i+1]) is not None)):
# HH[ ]h or MM[ ]m or SS[.ss][ ]s
if l[i] == ' ':
i += 1
idx = info.hms(l[i])
while True:
if idx == 0:
res.hour = int(value)
if value % 1:
res.minute = int(60*(value % 1))
elif idx == 1:
res.minute = int(value)
if value % 1:
res.second = int(60*(value % 1))
elif idx == 2:
res.second, res.microsecond = \
_parsems(value_repr)
i += 1
if i >= len_l or idx == 2:
break
# 12h00
try:
value_repr = l[i]
value = float(value_repr)
except ValueError:
break
else:
i += 1
idx += 1
if i < len_l:
newidx = info.hms(l[i])
if newidx is not None:
idx = newidx
elif (i == len_l and l[i-2] == ' ' and
info.hms(l[i-3]) is not None):
# X h MM or X m SS
idx = info.hms(l[i-3]) + 1
if idx == 1:
res.minute = int(value)
if value % 1:
res.second = int(60*(value % 1))
elif idx == 2:
res.second, res.microsecond = \
_parsems(value_repr)
i += 1
elif i+1 < len_l and l[i] == ':':
# HH:MM[:SS[.ss]]
res.hour = int(value)
i += 1
value = float(l[i])
res.minute = int(value)
if value % 1:
res.second = int(60*(value % 1))
i += 1
if i < len_l and l[i] == ':':
res.second, res.microsecond = _parsems(l[i+1])
i += 2
elif i < len_l and l[i] in ('-', '/', '.'):
sep = l[i]
ymd.append(value_repr)
i += 1
if i < len_l and not info.jump(l[i]):
try:
# 01-01[-01]
ymd.append(l[i])
except ValueError:
# 01-Jan[-01]
value = info.month(l[i])
if value is not None:
ymd.append(value)
assert mstridx == -1
mstridx = len(ymd)-1
else:
return None, None
i += 1
if i < len_l and l[i] == sep:
# We have three members
i += 1
value = info.month(l[i])
if value is not None:
ymd.append(value)
mstridx = len(ymd)-1
assert mstridx == -1
else:
ymd.append(l[i])
i += 1
elif i >= len_l or info.jump(l[i]):
if i+1 < len_l and info.ampm(l[i+1]) is not None:
# 12 am
res.hour = int(value)
if res.hour < 12 and info.ampm(l[i+1]) == 1:
res.hour += 12
elif res.hour == 12 and info.ampm(l[i+1]) == 0:
res.hour = 0
i += 1
else:
# Year, month or day
ymd.append(value)
i += 1
elif info.ampm(l[i]) is not None:
# 12am
res.hour = int(value)
if res.hour < 12 and info.ampm(l[i]) == 1:
res.hour += 12
elif res.hour == 12 and info.ampm(l[i]) == 0:
res.hour = 0
i += 1
elif not fuzzy:
return None, None
else:
i += 1
continue
# Check weekday
value = info.weekday(l[i])
if value is not None:
res.weekday = value
i += 1
continue
# Check month name
value = info.month(l[i])
if value is not None:
ymd.append(value)
assert mstridx == -1
mstridx = len(ymd)-1
i += 1
if i < len_l:
if l[i] in ('-', '/'):
# Jan-01[-99]
sep = l[i]
i += 1
ymd.append(l[i])
i += 1
if i < len_l and l[i] == sep:
# Jan-01-99
i += 1
ymd.append(l[i])
i += 1
elif (i+3 < len_l and l[i] == l[i+2] == ' '
and info.pertain(l[i+1])):
# Jan of 01
# In this case, 01 is clearly year
try:
value = int(l[i+3])
except ValueError:
# Wrong guess
pass
else:
# Convert it here to become unambiguous
ymd.append(str(info.convertyear(value)))
i += 4
continue
# Check am/pm
value = info.ampm(l[i])
if value is not None:
# For fuzzy parsing, 'a' or 'am' (both valid English words)
# may erroneously trigger the AM/PM flag. Deal with that
# here.
val_is_ampm = True
# If there's already an AM/PM flag, this one isn't one.
if fuzzy and res.ampm is not None:
val_is_ampm = False
# If AM/PM is found and hour is not, raise a ValueError
if res.hour is None:
if fuzzy:
val_is_ampm = False
else:
raise ValueError('No hour specified with ' +
'AM or PM flag.')
elif not 0 <= res.hour <= 12:
# If AM/PM is found, it's a 12 hour clock, so raise
# an error for invalid range
if fuzzy:
val_is_ampm = False
else:
raise ValueError('Invalid hour specified for ' +
'12-hour clock.')
if val_is_ampm:
if value == 1 and res.hour < 12:
res.hour += 12
elif value == 0 and res.hour == 12:
res.hour = 0
res.ampm = value
i += 1
continue
# Check for a timezone name
if (res.hour is not None and len(l[i]) <= 5 and
res.tzname is None and res.tzoffset is None and
not [x for x in l[i] if x not in
string.ascii_uppercase]):
res.tzname = l[i]
res.tzoffset = info.tzoffset(res.tzname)
i += 1
# Check for something like GMT+3, or BRST+3. Notice
# that it doesn't mean "I am 3 hours after GMT", but
# "my time +3 is GMT". If found, we reverse the
# logic so that timezone parsing code will get it
# right.
if i < len_l and l[i] in ('+', '-'):
l[i] = ('+', '-')[l[i] == '+']
res.tzoffset = None
if info.utczone(res.tzname):
# With something like GMT+3, the timezone
# is *not* GMT.
res.tzname = None
continue
# Check for a numbered timezone
if res.hour is not None and l[i] in ('+', '-'):
signal = (-1, 1)[l[i] == '+']
i += 1
len_li = len(l[i])
if len_li == 4:
# -0300
res.tzoffset = int(l[i][:2])*3600+int(l[i][2:])*60
elif i+1 < len_l and l[i+1] == ':':
# -03:00
res.tzoffset = int(l[i])*3600+int(l[i+2])*60
i += 2
elif len_li <= 2:
# -[0]3
res.tzoffset = int(l[i][:2])*3600
else:
return None, None
i += 1
res.tzoffset *= signal
# Look for a timezone name between parenthesis
if (i+3 < len_l and
info.jump(l[i]) and l[i+1] == '(' and l[i+3] == ')' and
3 <= len(l[i+2]) <= 5 and
not [x for x in l[i+2]
if x not in string.ascii_uppercase]):
# -0300 (BRST)
res.tzname = l[i+2]
i += 4
continue
# Check jumps
if not (info.jump(l[i]) or fuzzy):
return None, None
if last_skipped_token_i == i - 1:
# recombine the tokens
skipped_tokens[-1] += l[i]
else:
# just append
skipped_tokens.append(l[i])
last_skipped_token_i = i
i += 1
# Process year/month/day
year, month, day = ymd.resolve_ymd(mstridx, yearfirst, dayfirst)
if year is not None:
res.year = year
res.century_specified = ymd.century_specified
if month is not None:
res.month = month
if day is not None:
res.day = day
except (IndexError, ValueError, AssertionError):
return None, None
if not info.validate(res):
return None, None
if fuzzy_with_tokens:
return res, tuple(skipped_tokens)
else:
return res, None
DEFAULTPARSER = parser()
def parse(timestr, parserinfo=None, **kwargs):
"""
Parse a string in one of the supported formats, using the
``parserinfo`` parameters.
:param timestr:
A string containing a date/time stamp.
:param parserinfo:
A :class:`parserinfo` object containing parameters for the parser.
If ``None``, the default arguments to the :class:`parserinfo`
constructor are used.
The ``**kwargs`` parameter takes the following keyword arguments:
:param default:
The default datetime object, if this is a datetime object and not
``None``, elements specified in ``timestr`` replace elements in the
default object.
:param ignoretz:
If set ``True``, time zones in parsed strings are ignored and a naive
:class:`datetime` object is returned.
:param tzinfos:
Additional time zone names / aliases which may be present in the
string. This argument maps time zone names (and optionally offsets
from those time zones) to time zones. This parameter can be a
dictionary with timezone aliases mapping time zone names to time
zones or a function taking two parameters (``tzname`` and
``tzoffset``) and returning a time zone.
The timezones to which the names are mapped can be an integer
offset from UTC in minutes or a :class:`tzinfo` object.
.. doctest::
:options: +NORMALIZE_WHITESPACE
>>> from dateutil.parser import parse
>>> from dateutil.tz import gettz
>>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
>>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
>>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
datetime.datetime(2012, 1, 19, 17, 21,
tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))
This parameter is ignored if ``ignoretz`` is set.
:param dayfirst:
Whether to interpret the first value in an ambiguous 3-integer date
(e.g. 01/05/09) as the day (``True``) or month (``False``). If
``yearfirst`` is set to ``True``, this distinguishes between YDM and
YMD. If set to ``None``, this value is retrieved from the current
:class:`parserinfo` object (which itself defaults to ``False``).
:param yearfirst:
Whether to interpret the first value in an ambiguous 3-integer date
(e.g. 01/05/09) as the year. If ``True``, the first number is taken to
be the year, otherwise the last number is taken to be the year. If
this is set to ``None``, the value is retrieved from the current
:class:`parserinfo` object (which itself defaults to ``False``).
:param fuzzy:
Whether to allow fuzzy parsing, allowing for string like "Today is
January 1, 2047 at 8:21:00AM".
:param fuzzy_with_tokens:
If ``True``, ``fuzzy`` is automatically set to True, and the parser
will return a tuple where the first element is the parsed
:class:`datetime.datetime` datetimestamp and the second element is
a tuple containing the portions of the string which were ignored:
.. doctest::
>>> from dateutil.parser import parse
>>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
(datetime.datetime(2011, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))
:return:
Returns a :class:`datetime.datetime` object or, if the
``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
first element being a :class:`datetime.datetime` object, the second
a tuple containing the fuzzy tokens.
:raises ValueError:
Raised for invalid or unknown string format, if the provided
:class:`tzinfo` is not in a valid format, or if an invalid date
would be created.
:raises OverflowError:
Raised if the parsed date exceeds the largest valid C integer on
your system.
"""
if parserinfo:
return parser(parserinfo).parse(timestr, **kwargs)
else:
return DEFAULTPARSER.parse(timestr, **kwargs)
class _tzparser(object):
class _result(_resultbase):
__slots__ = ["stdabbr", "stdoffset", "dstabbr", "dstoffset",
"start", "end"]
class _attr(_resultbase):
__slots__ = ["month", "week", "weekday",
"yday", "jyday", "day", "time"]
def __repr__(self):
return self._repr("")
def __init__(self):
_resultbase.__init__(self)
self.start = self._attr()
self.end = self._attr()
def parse(self, tzstr):
res = self._result()
l = _timelex.split(tzstr)
try:
len_l = len(l)
i = 0
while i < len_l:
# BRST+3[BRDT[+2]]
j = i
while j < len_l and not [x for x in l[j]
if x in "0123456789:,-+"]:
j += 1
if j != i:
if not res.stdabbr:
offattr = "stdoffset"
res.stdabbr = "".join(l[i:j])
else:
offattr = "dstoffset"
res.dstabbr = "".join(l[i:j])
i = j
if (i < len_l and (l[i] in ('+', '-') or l[i][0] in
"0123456789")):
if l[i] in ('+', '-'):
# Yes, that's right. See the TZ variable
# documentation.
signal = (1, -1)[l[i] == '+']
i += 1
else:
signal = -1
len_li = len(l[i])
if len_li == 4:
# -0300
setattr(res, offattr, (int(l[i][:2])*3600 +
int(l[i][2:])*60)*signal)
elif i+1 < len_l and l[i+1] == ':':
# -03:00
setattr(res, offattr,
(int(l[i])*3600+int(l[i+2])*60)*signal)
i += 2
elif len_li <= 2:
# -[0]3
setattr(res, offattr,
int(l[i][:2])*3600*signal)
else:
return None
i += 1
if res.dstabbr:
break
else:
break
if i < len_l:
for j in range(i, len_l):
if l[j] == ';':
l[j] = ','
assert l[i] == ','
i += 1
if i >= len_l:
pass
elif (8 <= l.count(',') <= 9 and
not [y for x in l[i:] if x != ','
for y in x if y not in "0123456789"]):
# GMT0BST,3,0,30,3600,10,0,26,7200[,3600]
for x in (res.start, res.end):
x.month = int(l[i])
i += 2
if l[i] == '-':
value = int(l[i+1])*-1
i += 1
else:
value = int(l[i])
i += 2
if value:
x.week = value
x.weekday = (int(l[i])-1) % 7
else:
x.day = int(l[i])
i += 2
x.time = int(l[i])
i += 2
if i < len_l:
if l[i] in ('-', '+'):
signal = (-1, 1)[l[i] == "+"]
i += 1
else:
signal = 1
res.dstoffset = (res.stdoffset+int(l[i]))*signal
elif (l.count(',') == 2 and l[i:].count('/') <= 2 and
not [y for x in l[i:] if x not in (',', '/', 'J', 'M',
'.', '-', ':')
for y in x if y not in "0123456789"]):
for x in (res.start, res.end):
if l[i] == 'J':
# non-leap year day (1 based)
i += 1
x.jyday = int(l[i])
elif l[i] == 'M':
# month[-.]week[-.]weekday
i += 1
x.month = int(l[i])
i += 1
assert l[i] in ('-', '.')
i += 1
x.week = int(l[i])
if x.week == 5:
x.week = -1
i += 1
assert l[i] in ('-', '.')
i += 1
x.weekday = (int(l[i])-1) % 7
else:
# year day (zero based)
x.yday = int(l[i])+1
i += 1
if i < len_l and l[i] == '/':
i += 1
# start time
len_li = len(l[i])
if len_li == 4:
# -0300
x.time = (int(l[i][:2])*3600+int(l[i][2:])*60)
elif i+1 < len_l and l[i+1] == ':':
# -03:00
x.time = int(l[i])*3600+int(l[i+2])*60
i += 2
if i+1 < len_l and l[i+1] == ':':
i += 2
x.time += int(l[i])
elif len_li <= 2:
# -[0]3
x.time = (int(l[i][:2])*3600)
else:
return None
i += 1
assert i == len_l or l[i] == ','
i += 1
assert i >= len_l
except (IndexError, ValueError, AssertionError):
return None
return res
DEFAULTTZPARSER = _tzparser()
def _parsetz(tzstr):
return DEFAULTTZPARSER.parse(tzstr)
def _parsems(value):
"""Parse a I[.F] seconds value into (seconds, microseconds)."""
if "." not in value:
return int(value), 0
else:
i, f = value.split(".")
return int(i), int(f.ljust(6, "0")[:6])
# vim:ts=4:sw=4:et
| gpl-3.0 |
HybridF5/jacket | jacket/tests/storage/unit/backup/fake_google_client.py | 13 | 4615 | # Copyright (C) 2012 Hewlett-Packard Development Company, L.P.
# Copyright (C) 2016 Vedams Inc.
# Copyright (C) 2016 Google Inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import json
import os
import zlib
from googleapiclient import errors
from oauth2client import client
from oslo_utils import units
import six
class FakeGoogleObjectInsertExecute(object):
def __init__(self, *args, **kwargs):
self.container_name = kwargs['bucket']
def execute(self, *args, **kwargs):
if self.container_name == 'gcs_api_failure':
raise errors.Error
return {u'md5Hash': u'Z2NzY2luZGVybWQ1'}
class FakeGoogleObjectListExecute(object):
def __init__(self, *args, **kwargs):
self.container_name = kwargs['bucket']
def execute(self, *args, **kwargs):
if self.container_name == 'gcs_connection_failure':
raise Exception
return {'items': [{'name': 'backup_001'},
{'name': 'backup_002'},
{'name': 'backup_003'}]}
class FakeGoogleBucketListExecute(object):
def __init__(self, *args, **kwargs):
self.container_name = kwargs['prefix']
def execute(self, *args, **kwargs):
if self.container_name == 'gcs_oauth2_failure':
raise client.Error
return {u'items': [{u'name': u'gcscinderbucket'},
{u'name': u'gcsbucket'}]}
class FakeGoogleBucketInsertExecute(object):
def execute(self, *args, **kwargs):
pass
class FakeMediaObject(object):
def __init__(self, *args, **kwargs):
self.bucket_name = kwargs['bucket']
self.object_name = kwargs['object']
class FakeGoogleObject(object):
def insert(self, *args, **kwargs):
return FakeGoogleObjectInsertExecute(*args, **kwargs)
def get_media(self, *args, **kwargs):
return FakeMediaObject(*args, **kwargs)
def list(self, *args, **kwargs):
return FakeGoogleObjectListExecute(*args, **kwargs)
class FakeGoogleBucket(object):
def list(self, *args, **kwargs):
return FakeGoogleBucketListExecute(*args, **kwargs)
def insert(self, *args, **kwargs):
return FakeGoogleBucketInsertExecute()
class FakeGoogleDiscovery(object):
"""Logs calls instead of executing."""
def __init__(self, *args, **kwargs):
pass
@classmethod
def Build(self, *args, **kargs):
return FakeDiscoveryBuild()
class FakeDiscoveryBuild(object):
"""Logging calls instead of executing."""
def __init__(self, *args, **kwargs):
pass
def objects(self):
return FakeGoogleObject()
def buckets(self):
return FakeGoogleBucket()
class FakeGoogleCredentials(object):
def __init__(self, *args, **kwargs):
pass
@classmethod
def from_stream(self, *args, **kwargs):
pass
class FakeGoogleMediaIoBaseDownload(object):
def __init__(self, fh, req, chunksize=None):
if 'metadata' in req.object_name:
metadata = {}
metadata['version'] = '1.0.0'
metadata['backup_id'] = 123
metadata['volume_id'] = 123
metadata['backup_name'] = 'fake backup'
metadata['backup_description'] = 'fake backup description'
metadata['created_at'] = '2016-01-09 11:20:54,805'
metadata['objects'] = [{
'backup_001': {'compression': 'zlib', 'length': 10,
'offset': 0},
'backup_002': {'compression': 'zlib', 'length': 10,
'offset': 10},
'backup_003': {'compression': 'zlib', 'length': 10,
'offset': 20}
}]
metadata_json = json.dumps(metadata, sort_keys=True, indent=2)
if six.PY3:
metadata_json = metadata_json.encode('utf-8')
fh.write(metadata_json)
else:
fh.write(zlib.compress(os.urandom(units.Mi)))
def next_chunk(self, **kwargs):
return (100, True)
| apache-2.0 |
ToontownUprising/src | toontown/fishing/DistributedFishingPondAI.py | 5 | 1691 | from direct.directnotify.DirectNotifyGlobal import *
from direct.distributed.DistributedObjectAI import DistributedObjectAI
from toontown.fishing import FishingTargetGlobals
from toontown.fishing.DistributedFishingTargetAI import DistributedFishingTargetAI
class DistributedFishingPondAI(DistributedObjectAI):
notify = directNotify.newCategory("DistributedFishingPondAI")
def __init__(self, air):
DistributedObjectAI.__init__(self, air)
self.area = None
self.targets = {}
self.spots = {}
self.bingoMgr = None
def start(self):
for _ in xrange(FishingTargetGlobals.getNumTargets(self.area)):
fishingTarget = DistributedFishingTargetAI(simbase.air)
fishingTarget.setPondDoId(self.doId)
fishingTarget.generateWithRequired(self.zoneId)
def hitTarget(self, target):
avId = self.air.getAvatarIdFromSender()
if self.targets.get(target) is None:
self.air.writeServerEvent('suspicious', avId, 'Toon tried to hit nonexistent fishing target!')
return
spot = self.hasToon(avId)
if spot:
spot.rewardIfValid(target)
return
self.air.writeServerEvent('suspicious', avId, 'Toon tried to catch fish while not fishing!')
def addTarget(self, target):
self.targets[target.doId] = target
def addSpot(self, spot):
self.spots[spot.doId] = spot
def setArea(self, area):
self.area = area
def getArea(self):
return self.area
def hasToon(self, avId):
for spot in self.spots:
if self.spots[spot].avId == avId:
return self.spots[spot]
| mit |
nicolargo/intellij-community | python/helpers/pydev/pydevd_attach_to_process/winappdbg/textio.py | 102 | 62691 | #!~/.wine/drive_c/Python25/python.exe
# -*- coding: utf-8 -*-
# Copyright (c) 2009-2014, Mario Vilas
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice,this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""
Functions for text input, logging or text output.
@group Helpers:
HexDump,
HexInput,
HexOutput,
Color,
Table,
Logger
DebugLog
CrashDump
"""
__revision__ = "$Id$"
__all__ = [
'HexDump',
'HexInput',
'HexOutput',
'Color',
'Table',
'CrashDump',
'DebugLog',
'Logger',
]
import sys
from winappdbg import win32
from winappdbg import compat
from winappdbg.util import StaticClass
import re
import time
import struct
import traceback
#------------------------------------------------------------------------------
class HexInput (StaticClass):
"""
Static functions for user input parsing.
The counterparts for each method are in the L{HexOutput} class.
"""
@staticmethod
def integer(token):
"""
Convert numeric strings into integers.
@type token: str
@param token: String to parse.
@rtype: int
@return: Parsed integer value.
"""
token = token.strip()
neg = False
if token.startswith(compat.b('-')):
token = token[1:]
neg = True
if token.startswith(compat.b('0x')):
result = int(token, 16) # hexadecimal
elif token.startswith(compat.b('0b')):
result = int(token[2:], 2) # binary
elif token.startswith(compat.b('0o')):
result = int(token, 8) # octal
else:
try:
result = int(token) # decimal
except ValueError:
result = int(token, 16) # hexadecimal (no "0x" prefix)
if neg:
result = -result
return result
@staticmethod
def address(token):
"""
Convert numeric strings into memory addresses.
@type token: str
@param token: String to parse.
@rtype: int
@return: Parsed integer value.
"""
return int(token, 16)
@staticmethod
def hexadecimal(token):
"""
Convert a strip of hexadecimal numbers into binary data.
@type token: str
@param token: String to parse.
@rtype: str
@return: Parsed string value.
"""
token = ''.join([ c for c in token if c.isalnum() ])
if len(token) % 2 != 0:
raise ValueError("Missing characters in hex data")
data = ''
for i in compat.xrange(0, len(token), 2):
x = token[i:i+2]
d = int(x, 16)
s = struct.pack('<B', d)
data += s
return data
@staticmethod
def pattern(token):
"""
Convert an hexadecimal search pattern into a POSIX regular expression.
For example, the following pattern::
"B8 0? ?0 ?? ??"
Would match the following data::
"B8 0D F0 AD BA" # mov eax, 0xBAADF00D
@type token: str
@param token: String to parse.
@rtype: str
@return: Parsed string value.
"""
token = ''.join([ c for c in token if c == '?' or c.isalnum() ])
if len(token) % 2 != 0:
raise ValueError("Missing characters in hex data")
regexp = ''
for i in compat.xrange(0, len(token), 2):
x = token[i:i+2]
if x == '??':
regexp += '.'
elif x[0] == '?':
f = '\\x%%.1x%s' % x[1]
x = ''.join([ f % c for c in compat.xrange(0, 0x10) ])
regexp = '%s[%s]' % (regexp, x)
elif x[1] == '?':
f = '\\x%s%%.1x' % x[0]
x = ''.join([ f % c for c in compat.xrange(0, 0x10) ])
regexp = '%s[%s]' % (regexp, x)
else:
regexp = '%s\\x%s' % (regexp, x)
return regexp
@staticmethod
def is_pattern(token):
"""
Determine if the given argument is a valid hexadecimal pattern to be
used with L{pattern}.
@type token: str
@param token: String to parse.
@rtype: bool
@return:
C{True} if it's a valid hexadecimal pattern, C{False} otherwise.
"""
return re.match(r"^(?:[\?A-Fa-f0-9][\?A-Fa-f0-9]\s*)+$", token)
@classmethod
def integer_list_file(cls, filename):
"""
Read a list of integers from a file.
The file format is:
- # anywhere in the line begins a comment
- leading and trailing spaces are ignored
- empty lines are ignored
- integers can be specified as:
- decimal numbers ("100" is 100)
- hexadecimal numbers ("0x100" is 256)
- binary numbers ("0b100" is 4)
- octal numbers ("0100" is 64)
@type filename: str
@param filename: Name of the file to read.
@rtype: list( int )
@return: List of integers read from the file.
"""
count = 0
result = list()
fd = open(filename, 'r')
for line in fd:
count = count + 1
if '#' in line:
line = line[ : line.find('#') ]
line = line.strip()
if line:
try:
value = cls.integer(line)
except ValueError:
e = sys.exc_info()[1]
msg = "Error in line %d of %s: %s"
msg = msg % (count, filename, str(e))
raise ValueError(msg)
result.append(value)
return result
@classmethod
def string_list_file(cls, filename):
"""
Read a list of string values from a file.
The file format is:
- # anywhere in the line begins a comment
- leading and trailing spaces are ignored
- empty lines are ignored
- strings cannot span over a single line
@type filename: str
@param filename: Name of the file to read.
@rtype: list
@return: List of integers and strings read from the file.
"""
count = 0
result = list()
fd = open(filename, 'r')
for line in fd:
count = count + 1
if '#' in line:
line = line[ : line.find('#') ]
line = line.strip()
if line:
result.append(line)
return result
@classmethod
def mixed_list_file(cls, filename):
"""
Read a list of mixed values from a file.
The file format is:
- # anywhere in the line begins a comment
- leading and trailing spaces are ignored
- empty lines are ignored
- strings cannot span over a single line
- integers can be specified as:
- decimal numbers ("100" is 100)
- hexadecimal numbers ("0x100" is 256)
- binary numbers ("0b100" is 4)
- octal numbers ("0100" is 64)
@type filename: str
@param filename: Name of the file to read.
@rtype: list
@return: List of integers and strings read from the file.
"""
count = 0
result = list()
fd = open(filename, 'r')
for line in fd:
count = count + 1
if '#' in line:
line = line[ : line.find('#') ]
line = line.strip()
if line:
try:
value = cls.integer(line)
except ValueError:
value = line
result.append(value)
return result
#------------------------------------------------------------------------------
class HexOutput (StaticClass):
"""
Static functions for user output parsing.
The counterparts for each method are in the L{HexInput} class.
@type integer_size: int
@cvar integer_size: Default size in characters of an outputted integer.
This value is platform dependent.
@type address_size: int
@cvar address_size: Default Number of bits of the target architecture.
This value is platform dependent.
"""
integer_size = (win32.SIZEOF(win32.DWORD) * 2) + 2
address_size = (win32.SIZEOF(win32.SIZE_T) * 2) + 2
@classmethod
def integer(cls, integer, bits = None):
"""
@type integer: int
@param integer: Integer.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexOutput.integer_size}
@rtype: str
@return: Text output.
"""
if bits is None:
integer_size = cls.integer_size
else:
integer_size = (bits / 4) + 2
if integer >= 0:
return ('0x%%.%dx' % (integer_size - 2)) % integer
return ('-0x%%.%dx' % (integer_size - 2)) % -integer
@classmethod
def address(cls, address, bits = None):
"""
@type address: int
@param address: Memory address.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexOutput.address_size}
@rtype: str
@return: Text output.
"""
if bits is None:
address_size = cls.address_size
bits = win32.bits
else:
address_size = (bits / 4) + 2
if address < 0:
address = ((2 ** bits) - 1) ^ ~address
return ('0x%%.%dx' % (address_size - 2)) % address
@staticmethod
def hexadecimal(data):
"""
Convert binary data to a string of hexadecimal numbers.
@type data: str
@param data: Binary data.
@rtype: str
@return: Hexadecimal representation.
"""
return HexDump.hexadecimal(data, separator = '')
@classmethod
def integer_list_file(cls, filename, values, bits = None):
"""
Write a list of integers to a file.
If a file of the same name exists, it's contents are replaced.
See L{HexInput.integer_list_file} for a description of the file format.
@type filename: str
@param filename: Name of the file to write.
@type values: list( int )
@param values: List of integers to write to the file.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexOutput.integer_size}
"""
fd = open(filename, 'w')
for integer in values:
print >> fd, cls.integer(integer, bits)
fd.close()
@classmethod
def string_list_file(cls, filename, values):
"""
Write a list of strings to a file.
If a file of the same name exists, it's contents are replaced.
See L{HexInput.string_list_file} for a description of the file format.
@type filename: str
@param filename: Name of the file to write.
@type values: list( int )
@param values: List of strings to write to the file.
"""
fd = open(filename, 'w')
for string in values:
print >> fd, string
fd.close()
@classmethod
def mixed_list_file(cls, filename, values, bits):
"""
Write a list of mixed values to a file.
If a file of the same name exists, it's contents are replaced.
See L{HexInput.mixed_list_file} for a description of the file format.
@type filename: str
@param filename: Name of the file to write.
@type values: list( int )
@param values: List of mixed values to write to the file.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexOutput.integer_size}
"""
fd = open(filename, 'w')
for original in values:
try:
parsed = cls.integer(original, bits)
except TypeError:
parsed = repr(original)
print >> fd, parsed
fd.close()
#------------------------------------------------------------------------------
class HexDump (StaticClass):
"""
Static functions for hexadecimal dumps.
@type integer_size: int
@cvar integer_size: Size in characters of an outputted integer.
This value is platform dependent.
@type address_size: int
@cvar address_size: Size in characters of an outputted address.
This value is platform dependent.
"""
integer_size = (win32.SIZEOF(win32.DWORD) * 2)
address_size = (win32.SIZEOF(win32.SIZE_T) * 2)
@classmethod
def integer(cls, integer, bits = None):
"""
@type integer: int
@param integer: Integer.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.integer_size}
@rtype: str
@return: Text output.
"""
if bits is None:
integer_size = cls.integer_size
else:
integer_size = bits / 4
return ('%%.%dX' % integer_size) % integer
@classmethod
def address(cls, address, bits = None):
"""
@type address: int
@param address: Memory address.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text output.
"""
if bits is None:
address_size = cls.address_size
bits = win32.bits
else:
address_size = bits / 4
if address < 0:
address = ((2 ** bits) - 1) ^ ~address
return ('%%.%dX' % address_size) % address
@staticmethod
def printable(data):
"""
Replace unprintable characters with dots.
@type data: str
@param data: Binary data.
@rtype: str
@return: Printable text.
"""
result = ''
for c in data:
if 32 < ord(c) < 128:
result += c
else:
result += '.'
return result
@staticmethod
def hexadecimal(data, separator = ''):
"""
Convert binary data to a string of hexadecimal numbers.
@type data: str
@param data: Binary data.
@type separator: str
@param separator:
Separator between the hexadecimal representation of each character.
@rtype: str
@return: Hexadecimal representation.
"""
return separator.join( [ '%.2x' % ord(c) for c in data ] )
@staticmethod
def hexa_word(data, separator = ' '):
"""
Convert binary data to a string of hexadecimal WORDs.
@type data: str
@param data: Binary data.
@type separator: str
@param separator:
Separator between the hexadecimal representation of each WORD.
@rtype: str
@return: Hexadecimal representation.
"""
if len(data) & 1 != 0:
data += '\0'
return separator.join( [ '%.4x' % struct.unpack('<H', data[i:i+2])[0] \
for i in compat.xrange(0, len(data), 2) ] )
@staticmethod
def hexa_dword(data, separator = ' '):
"""
Convert binary data to a string of hexadecimal DWORDs.
@type data: str
@param data: Binary data.
@type separator: str
@param separator:
Separator between the hexadecimal representation of each DWORD.
@rtype: str
@return: Hexadecimal representation.
"""
if len(data) & 3 != 0:
data += '\0' * (4 - (len(data) & 3))
return separator.join( [ '%.8x' % struct.unpack('<L', data[i:i+4])[0] \
for i in compat.xrange(0, len(data), 4) ] )
@staticmethod
def hexa_qword(data, separator = ' '):
"""
Convert binary data to a string of hexadecimal QWORDs.
@type data: str
@param data: Binary data.
@type separator: str
@param separator:
Separator between the hexadecimal representation of each QWORD.
@rtype: str
@return: Hexadecimal representation.
"""
if len(data) & 7 != 0:
data += '\0' * (8 - (len(data) & 7))
return separator.join( [ '%.16x' % struct.unpack('<Q', data[i:i+8])[0]\
for i in compat.xrange(0, len(data), 8) ] )
@classmethod
def hexline(cls, data, separator = ' ', width = None):
"""
Dump a line of hexadecimal numbers from binary data.
@type data: str
@param data: Binary data.
@type separator: str
@param separator:
Separator between the hexadecimal representation of each character.
@type width: int
@param width:
(Optional) Maximum number of characters to convert per text line.
This value is also used for padding.
@rtype: str
@return: Multiline output text.
"""
if width is None:
fmt = '%s %s'
else:
fmt = '%%-%ds %%-%ds' % ((len(separator)+2)*width-1, width)
return fmt % (cls.hexadecimal(data, separator), cls.printable(data))
@classmethod
def hexblock(cls, data, address = None,
bits = None,
separator = ' ',
width = 8):
"""
Dump a block of hexadecimal numbers from binary data.
Also show a printable text version of the data.
@type data: str
@param data: Binary data.
@type address: str
@param address: Memory address where the data was read from.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@type separator: str
@param separator:
Separator between the hexadecimal representation of each character.
@type width: int
@param width:
(Optional) Maximum number of characters to convert per text line.
@rtype: str
@return: Multiline output text.
"""
return cls.hexblock_cb(cls.hexline, data, address, bits, width,
cb_kwargs = {'width' : width, 'separator' : separator})
@classmethod
def hexblock_cb(cls, callback, data, address = None,
bits = None,
width = 16,
cb_args = (),
cb_kwargs = {}):
"""
Dump a block of binary data using a callback function to convert each
line of text.
@type callback: function
@param callback: Callback function to convert each line of data.
@type data: str
@param data: Binary data.
@type address: str
@param address:
(Optional) Memory address where the data was read from.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@type cb_args: str
@param cb_args:
(Optional) Arguments to pass to the callback function.
@type cb_kwargs: str
@param cb_kwargs:
(Optional) Keyword arguments to pass to the callback function.
@type width: int
@param width:
(Optional) Maximum number of bytes to convert per text line.
@rtype: str
@return: Multiline output text.
"""
result = ''
if address is None:
for i in compat.xrange(0, len(data), width):
result = '%s%s\n' % ( result, \
callback(data[i:i+width], *cb_args, **cb_kwargs) )
else:
for i in compat.xrange(0, len(data), width):
result = '%s%s: %s\n' % (
result,
cls.address(address, bits),
callback(data[i:i+width], *cb_args, **cb_kwargs)
)
address += width
return result
@classmethod
def hexblock_byte(cls, data, address = None,
bits = None,
separator = ' ',
width = 16):
"""
Dump a block of hexadecimal BYTEs from binary data.
@type data: str
@param data: Binary data.
@type address: str
@param address: Memory address where the data was read from.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@type separator: str
@param separator:
Separator between the hexadecimal representation of each BYTE.
@type width: int
@param width:
(Optional) Maximum number of BYTEs to convert per text line.
@rtype: str
@return: Multiline output text.
"""
return cls.hexblock_cb(cls.hexadecimal, data,
address, bits, width,
cb_kwargs = {'separator': separator})
@classmethod
def hexblock_word(cls, data, address = None,
bits = None,
separator = ' ',
width = 8):
"""
Dump a block of hexadecimal WORDs from binary data.
@type data: str
@param data: Binary data.
@type address: str
@param address: Memory address where the data was read from.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@type separator: str
@param separator:
Separator between the hexadecimal representation of each WORD.
@type width: int
@param width:
(Optional) Maximum number of WORDs to convert per text line.
@rtype: str
@return: Multiline output text.
"""
return cls.hexblock_cb(cls.hexa_word, data,
address, bits, width * 2,
cb_kwargs = {'separator': separator})
@classmethod
def hexblock_dword(cls, data, address = None,
bits = None,
separator = ' ',
width = 4):
"""
Dump a block of hexadecimal DWORDs from binary data.
@type data: str
@param data: Binary data.
@type address: str
@param address: Memory address where the data was read from.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@type separator: str
@param separator:
Separator between the hexadecimal representation of each DWORD.
@type width: int
@param width:
(Optional) Maximum number of DWORDs to convert per text line.
@rtype: str
@return: Multiline output text.
"""
return cls.hexblock_cb(cls.hexa_dword, data,
address, bits, width * 4,
cb_kwargs = {'separator': separator})
@classmethod
def hexblock_qword(cls, data, address = None,
bits = None,
separator = ' ',
width = 2):
"""
Dump a block of hexadecimal QWORDs from binary data.
@type data: str
@param data: Binary data.
@type address: str
@param address: Memory address where the data was read from.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@type separator: str
@param separator:
Separator between the hexadecimal representation of each QWORD.
@type width: int
@param width:
(Optional) Maximum number of QWORDs to convert per text line.
@rtype: str
@return: Multiline output text.
"""
return cls.hexblock_cb(cls.hexa_qword, data,
address, bits, width * 8,
cb_kwargs = {'separator': separator})
#------------------------------------------------------------------------------
# TODO: implement an ANSI parser to simplify using colors
class Color (object):
"""
Colored console output.
"""
@staticmethod
def _get_text_attributes():
return win32.GetConsoleScreenBufferInfo().wAttributes
@staticmethod
def _set_text_attributes(wAttributes):
win32.SetConsoleTextAttribute(wAttributes = wAttributes)
#--------------------------------------------------------------------------
@classmethod
def can_use_colors(cls):
"""
Determine if we can use colors.
Colored output only works when the output is a real console, and fails
when redirected to a file or pipe. Call this method before issuing a
call to any other method of this class to make sure it's actually
possible to use colors.
@rtype: bool
@return: C{True} if it's possible to output text with color,
C{False} otherwise.
"""
try:
cls._get_text_attributes()
return True
except Exception:
return False
@classmethod
def reset(cls):
"Reset the colors to the default values."
cls._set_text_attributes(win32.FOREGROUND_GREY)
#--------------------------------------------------------------------------
#@classmethod
#def underscore(cls, on = True):
# wAttributes = cls._get_text_attributes()
# if on:
# wAttributes |= win32.COMMON_LVB_UNDERSCORE
# else:
# wAttributes &= ~win32.COMMON_LVB_UNDERSCORE
# cls._set_text_attributes(wAttributes)
#--------------------------------------------------------------------------
@classmethod
def default(cls):
"Make the current foreground color the default."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_GREY
wAttributes &= ~win32.FOREGROUND_INTENSITY
cls._set_text_attributes(wAttributes)
@classmethod
def light(cls):
"Make the current foreground color light."
wAttributes = cls._get_text_attributes()
wAttributes |= win32.FOREGROUND_INTENSITY
cls._set_text_attributes(wAttributes)
@classmethod
def dark(cls):
"Make the current foreground color dark."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_INTENSITY
cls._set_text_attributes(wAttributes)
@classmethod
def black(cls):
"Make the text foreground color black."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
#wAttributes |= win32.FOREGROUND_BLACK
cls._set_text_attributes(wAttributes)
@classmethod
def white(cls):
"Make the text foreground color white."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_GREY
cls._set_text_attributes(wAttributes)
@classmethod
def red(cls):
"Make the text foreground color red."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_RED
cls._set_text_attributes(wAttributes)
@classmethod
def green(cls):
"Make the text foreground color green."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_GREEN
cls._set_text_attributes(wAttributes)
@classmethod
def blue(cls):
"Make the text foreground color blue."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_BLUE
cls._set_text_attributes(wAttributes)
@classmethod
def cyan(cls):
"Make the text foreground color cyan."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_CYAN
cls._set_text_attributes(wAttributes)
@classmethod
def magenta(cls):
"Make the text foreground color magenta."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_MAGENTA
cls._set_text_attributes(wAttributes)
@classmethod
def yellow(cls):
"Make the text foreground color yellow."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_YELLOW
cls._set_text_attributes(wAttributes)
#--------------------------------------------------------------------------
@classmethod
def bk_default(cls):
"Make the current background color the default."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
#wAttributes |= win32.BACKGROUND_BLACK
wAttributes &= ~win32.BACKGROUND_INTENSITY
cls._set_text_attributes(wAttributes)
@classmethod
def bk_light(cls):
"Make the current background color light."
wAttributes = cls._get_text_attributes()
wAttributes |= win32.BACKGROUND_INTENSITY
cls._set_text_attributes(wAttributes)
@classmethod
def bk_dark(cls):
"Make the current background color dark."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_INTENSITY
cls._set_text_attributes(wAttributes)
@classmethod
def bk_black(cls):
"Make the text background color black."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
#wAttributes |= win32.BACKGROUND_BLACK
cls._set_text_attributes(wAttributes)
@classmethod
def bk_white(cls):
"Make the text background color white."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_GREY
cls._set_text_attributes(wAttributes)
@classmethod
def bk_red(cls):
"Make the text background color red."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_RED
cls._set_text_attributes(wAttributes)
@classmethod
def bk_green(cls):
"Make the text background color green."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_GREEN
cls._set_text_attributes(wAttributes)
@classmethod
def bk_blue(cls):
"Make the text background color blue."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_BLUE
cls._set_text_attributes(wAttributes)
@classmethod
def bk_cyan(cls):
"Make the text background color cyan."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_CYAN
cls._set_text_attributes(wAttributes)
@classmethod
def bk_magenta(cls):
"Make the text background color magenta."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_MAGENTA
cls._set_text_attributes(wAttributes)
@classmethod
def bk_yellow(cls):
"Make the text background color yellow."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.BACKGROUND_MASK
wAttributes |= win32.BACKGROUND_YELLOW
cls._set_text_attributes(wAttributes)
#------------------------------------------------------------------------------
# TODO: another class for ASCII boxes
class Table (object):
"""
Text based table. The number of columns and the width of each column
is automatically calculated.
"""
def __init__(self, sep = ' '):
"""
@type sep: str
@param sep: Separator between cells in each row.
"""
self.__cols = list()
self.__width = list()
self.__sep = sep
def addRow(self, *row):
"""
Add a row to the table. All items are converted to strings.
@type row: tuple
@keyword row: Each argument is a cell in the table.
"""
row = [ str(item) for item in row ]
len_row = [ len(item) for item in row ]
width = self.__width
len_old = len(width)
len_new = len(row)
known = min(len_old, len_new)
missing = len_new - len_old
if missing > 0:
width.extend( len_row[ -missing : ] )
elif missing < 0:
len_row.extend( [0] * (-missing) )
self.__width = [ max( width[i], len_row[i] ) for i in compat.xrange(len(len_row)) ]
self.__cols.append(row)
def justify(self, column, direction):
"""
Make the text in a column left or right justified.
@type column: int
@param column: Index of the column.
@type direction: int
@param direction:
C{-1} to justify left,
C{1} to justify right.
@raise IndexError: Bad column index.
@raise ValueError: Bad direction value.
"""
if direction == -1:
self.__width[column] = abs(self.__width[column])
elif direction == 1:
self.__width[column] = - abs(self.__width[column])
else:
raise ValueError("Bad direction value.")
def getWidth(self):
"""
Get the width of the text output for the table.
@rtype: int
@return: Width in characters for the text output,
including the newline character.
"""
width = 0
if self.__width:
width = sum( abs(x) for x in self.__width )
width = width + len(self.__width) * len(self.__sep) + 1
return width
def getOutput(self):
"""
Get the text output for the table.
@rtype: str
@return: Text output.
"""
return '%s\n' % '\n'.join( self.yieldOutput() )
def yieldOutput(self):
"""
Generate the text output for the table.
@rtype: generator of str
@return: Text output.
"""
width = self.__width
if width:
num_cols = len(width)
fmt = ['%%%ds' % -w for w in width]
if width[-1] > 0:
fmt[-1] = '%s'
fmt = self.__sep.join(fmt)
for row in self.__cols:
row.extend( [''] * (num_cols - len(row)) )
yield fmt % tuple(row)
def show(self):
"""
Print the text output for the table.
"""
print(self.getOutput())
#------------------------------------------------------------------------------
class CrashDump (StaticClass):
"""
Static functions for crash dumps.
@type reg_template: str
@cvar reg_template: Template for the L{dump_registers} method.
"""
# Templates for the dump_registers method.
reg_template = {
win32.ARCH_I386 : (
'eax=%(Eax).8x ebx=%(Ebx).8x ecx=%(Ecx).8x edx=%(Edx).8x esi=%(Esi).8x edi=%(Edi).8x\n'
'eip=%(Eip).8x esp=%(Esp).8x ebp=%(Ebp).8x %(efl_dump)s\n'
'cs=%(SegCs).4x ss=%(SegSs).4x ds=%(SegDs).4x es=%(SegEs).4x fs=%(SegFs).4x gs=%(SegGs).4x efl=%(EFlags).8x\n'
),
win32.ARCH_AMD64 : (
'rax=%(Rax).16x rbx=%(Rbx).16x rcx=%(Rcx).16x\n'
'rdx=%(Rdx).16x rsi=%(Rsi).16x rdi=%(Rdi).16x\n'
'rip=%(Rip).16x rsp=%(Rsp).16x rbp=%(Rbp).16x\n'
' r8=%(R8).16x r9=%(R9).16x r10=%(R10).16x\n'
'r11=%(R11).16x r12=%(R12).16x r13=%(R13).16x\n'
'r14=%(R14).16x r15=%(R15).16x\n'
'%(efl_dump)s\n'
'cs=%(SegCs).4x ss=%(SegSs).4x ds=%(SegDs).4x es=%(SegEs).4x fs=%(SegFs).4x gs=%(SegGs).4x efl=%(EFlags).8x\n'
),
}
@staticmethod
def dump_flags(efl):
"""
Dump the x86 processor flags.
The output mimics that of the WinDBG debugger.
Used by L{dump_registers}.
@type efl: int
@param efl: Value of the eFlags register.
@rtype: str
@return: Text suitable for logging.
"""
if efl is None:
return ''
efl_dump = 'iopl=%1d' % ((efl & 0x3000) >> 12)
if efl & 0x100000:
efl_dump += ' vip'
else:
efl_dump += ' '
if efl & 0x80000:
efl_dump += ' vif'
else:
efl_dump += ' '
# 0x20000 ???
if efl & 0x800:
efl_dump += ' ov' # Overflow
else:
efl_dump += ' no' # No overflow
if efl & 0x400:
efl_dump += ' dn' # Downwards
else:
efl_dump += ' up' # Upwards
if efl & 0x200:
efl_dump += ' ei' # Enable interrupts
else:
efl_dump += ' di' # Disable interrupts
# 0x100 trap flag
if efl & 0x80:
efl_dump += ' ng' # Negative
else:
efl_dump += ' pl' # Positive
if efl & 0x40:
efl_dump += ' zr' # Zero
else:
efl_dump += ' nz' # Nonzero
if efl & 0x10:
efl_dump += ' ac' # Auxiliary carry
else:
efl_dump += ' na' # No auxiliary carry
# 0x8 ???
if efl & 0x4:
efl_dump += ' pe' # Parity odd
else:
efl_dump += ' po' # Parity even
# 0x2 ???
if efl & 0x1:
efl_dump += ' cy' # Carry
else:
efl_dump += ' nc' # No carry
return efl_dump
@classmethod
def dump_registers(cls, registers, arch = None):
"""
Dump the x86/x64 processor register values.
The output mimics that of the WinDBG debugger.
@type registers: dict( str S{->} int )
@param registers: Dictionary mapping register names to their values.
@type arch: str
@param arch: Architecture of the machine whose registers were dumped.
Defaults to the current architecture.
Currently only the following architectures are supported:
- L{win32.ARCH_I386}
- L{win32.ARCH_AMD64}
@rtype: str
@return: Text suitable for logging.
"""
if registers is None:
return ''
if arch is None:
if 'Eax' in registers:
arch = win32.ARCH_I386
elif 'Rax' in registers:
arch = win32.ARCH_AMD64
else:
arch = 'Unknown'
if arch not in cls.reg_template:
msg = "Don't know how to dump the registers for architecture: %s"
raise NotImplementedError(msg % arch)
registers = registers.copy()
registers['efl_dump'] = cls.dump_flags( registers['EFlags'] )
return cls.reg_template[arch] % registers
@staticmethod
def dump_registers_peek(registers, data, separator = ' ', width = 16):
"""
Dump data pointed to by the given registers, if any.
@type registers: dict( str S{->} int )
@param registers: Dictionary mapping register names to their values.
This value is returned by L{Thread.get_context}.
@type data: dict( str S{->} str )
@param data: Dictionary mapping register names to the data they point to.
This value is returned by L{Thread.peek_pointers_in_registers}.
@rtype: str
@return: Text suitable for logging.
"""
if None in (registers, data):
return ''
names = compat.keys(data)
names.sort()
result = ''
for reg_name in names:
tag = reg_name.lower()
dumped = HexDump.hexline(data[reg_name], separator, width)
result += '%s -> %s\n' % (tag, dumped)
return result
@staticmethod
def dump_data_peek(data, base = 0,
separator = ' ',
width = 16,
bits = None):
"""
Dump data from pointers guessed within the given binary data.
@type data: str
@param data: Dictionary mapping offsets to the data they point to.
@type base: int
@param base: Base offset.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text suitable for logging.
"""
if data is None:
return ''
pointers = compat.keys(data)
pointers.sort()
result = ''
for offset in pointers:
dumped = HexDump.hexline(data[offset], separator, width)
address = HexDump.address(base + offset, bits)
result += '%s -> %s\n' % (address, dumped)
return result
@staticmethod
def dump_stack_peek(data, separator = ' ', width = 16, arch = None):
"""
Dump data from pointers guessed within the given stack dump.
@type data: str
@param data: Dictionary mapping stack offsets to the data they point to.
@type separator: str
@param separator:
Separator between the hexadecimal representation of each character.
@type width: int
@param width:
(Optional) Maximum number of characters to convert per text line.
This value is also used for padding.
@type arch: str
@param arch: Architecture of the machine whose registers were dumped.
Defaults to the current architecture.
@rtype: str
@return: Text suitable for logging.
"""
if data is None:
return ''
if arch is None:
arch = win32.arch
pointers = compat.keys(data)
pointers.sort()
result = ''
if pointers:
if arch == win32.ARCH_I386:
spreg = 'esp'
elif arch == win32.ARCH_AMD64:
spreg = 'rsp'
else:
spreg = 'STACK' # just a generic tag
tag_fmt = '[%s+0x%%.%dx]' % (spreg, len( '%x' % pointers[-1] ) )
for offset in pointers:
dumped = HexDump.hexline(data[offset], separator, width)
tag = tag_fmt % offset
result += '%s -> %s\n' % (tag, dumped)
return result
@staticmethod
def dump_stack_trace(stack_trace, bits = None):
"""
Dump a stack trace, as returned by L{Thread.get_stack_trace} with the
C{bUseLabels} parameter set to C{False}.
@type stack_trace: list( int, int, str )
@param stack_trace: Stack trace as a list of tuples of
( return address, frame pointer, module filename )
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text suitable for logging.
"""
if not stack_trace:
return ''
table = Table()
table.addRow('Frame', 'Origin', 'Module')
for (fp, ra, mod) in stack_trace:
fp_d = HexDump.address(fp, bits)
ra_d = HexDump.address(ra, bits)
table.addRow(fp_d, ra_d, mod)
return table.getOutput()
@staticmethod
def dump_stack_trace_with_labels(stack_trace, bits = None):
"""
Dump a stack trace,
as returned by L{Thread.get_stack_trace_with_labels}.
@type stack_trace: list( int, int, str )
@param stack_trace: Stack trace as a list of tuples of
( return address, frame pointer, module filename )
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text suitable for logging.
"""
if not stack_trace:
return ''
table = Table()
table.addRow('Frame', 'Origin')
for (fp, label) in stack_trace:
table.addRow( HexDump.address(fp, bits), label )
return table.getOutput()
# TODO
# + Instead of a star when EIP points to, it would be better to show
# any register value (or other values like the exception address) that
# points to a location in the dissassembled code.
# + It'd be very useful to show some labels here.
# + It'd be very useful to show register contents for code at EIP
@staticmethod
def dump_code(disassembly, pc = None,
bLowercase = True,
bits = None):
"""
Dump a disassembly. Optionally mark where the program counter is.
@type disassembly: list of tuple( int, int, str, str )
@param disassembly: Disassembly dump as returned by
L{Process.disassemble} or L{Thread.disassemble_around_pc}.
@type pc: int
@param pc: (Optional) Program counter.
@type bLowercase: bool
@param bLowercase: (Optional) If C{True} convert the code to lowercase.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text suitable for logging.
"""
if not disassembly:
return ''
table = Table(sep = ' | ')
for (addr, size, code, dump) in disassembly:
if bLowercase:
code = code.lower()
if addr == pc:
addr = ' * %s' % HexDump.address(addr, bits)
else:
addr = ' %s' % HexDump.address(addr, bits)
table.addRow(addr, dump, code)
table.justify(1, 1)
return table.getOutput()
@staticmethod
def dump_code_line(disassembly_line, bShowAddress = True,
bShowDump = True,
bLowercase = True,
dwDumpWidth = None,
dwCodeWidth = None,
bits = None):
"""
Dump a single line of code. To dump a block of code use L{dump_code}.
@type disassembly_line: tuple( int, int, str, str )
@param disassembly_line: Single item of the list returned by
L{Process.disassemble} or L{Thread.disassemble_around_pc}.
@type bShowAddress: bool
@param bShowAddress: (Optional) If C{True} show the memory address.
@type bShowDump: bool
@param bShowDump: (Optional) If C{True} show the hexadecimal dump.
@type bLowercase: bool
@param bLowercase: (Optional) If C{True} convert the code to lowercase.
@type dwDumpWidth: int or None
@param dwDumpWidth: (Optional) Width in characters of the hex dump.
@type dwCodeWidth: int or None
@param dwCodeWidth: (Optional) Width in characters of the code.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text suitable for logging.
"""
if bits is None:
address_size = HexDump.address_size
else:
address_size = bits / 4
(addr, size, code, dump) = disassembly_line
dump = dump.replace(' ', '')
result = list()
fmt = ''
if bShowAddress:
result.append( HexDump.address(addr, bits) )
fmt += '%%%ds:' % address_size
if bShowDump:
result.append(dump)
if dwDumpWidth:
fmt += ' %%-%ds' % dwDumpWidth
else:
fmt += ' %s'
if bLowercase:
code = code.lower()
result.append(code)
if dwCodeWidth:
fmt += ' %%-%ds' % dwCodeWidth
else:
fmt += ' %s'
return fmt % tuple(result)
@staticmethod
def dump_memory_map(memoryMap, mappedFilenames = None, bits = None):
"""
Dump the memory map of a process. Optionally show the filenames for
memory mapped files as well.
@type memoryMap: list( L{win32.MemoryBasicInformation} )
@param memoryMap: Memory map returned by L{Process.get_memory_map}.
@type mappedFilenames: dict( int S{->} str )
@param mappedFilenames: (Optional) Memory mapped filenames
returned by L{Process.get_mapped_filenames}.
@type bits: int
@param bits:
(Optional) Number of bits of the target architecture.
The default is platform dependent. See: L{HexDump.address_size}
@rtype: str
@return: Text suitable for logging.
"""
if not memoryMap:
return ''
table = Table()
if mappedFilenames:
table.addRow("Address", "Size", "State", "Access", "Type", "File")
else:
table.addRow("Address", "Size", "State", "Access", "Type")
# For each memory block in the map...
for mbi in memoryMap:
# Address and size of memory block.
BaseAddress = HexDump.address(mbi.BaseAddress, bits)
RegionSize = HexDump.address(mbi.RegionSize, bits)
# State (free or allocated).
mbiState = mbi.State
if mbiState == win32.MEM_RESERVE:
State = "Reserved"
elif mbiState == win32.MEM_COMMIT:
State = "Commited"
elif mbiState == win32.MEM_FREE:
State = "Free"
else:
State = "Unknown"
# Page protection bits (R/W/X/G).
if mbiState != win32.MEM_COMMIT:
Protect = ""
else:
mbiProtect = mbi.Protect
if mbiProtect & win32.PAGE_NOACCESS:
Protect = "--- "
elif mbiProtect & win32.PAGE_READONLY:
Protect = "R-- "
elif mbiProtect & win32.PAGE_READWRITE:
Protect = "RW- "
elif mbiProtect & win32.PAGE_WRITECOPY:
Protect = "RC- "
elif mbiProtect & win32.PAGE_EXECUTE:
Protect = "--X "
elif mbiProtect & win32.PAGE_EXECUTE_READ:
Protect = "R-X "
elif mbiProtect & win32.PAGE_EXECUTE_READWRITE:
Protect = "RWX "
elif mbiProtect & win32.PAGE_EXECUTE_WRITECOPY:
Protect = "RCX "
else:
Protect = "??? "
if mbiProtect & win32.PAGE_GUARD:
Protect += "G"
else:
Protect += "-"
if mbiProtect & win32.PAGE_NOCACHE:
Protect += "N"
else:
Protect += "-"
if mbiProtect & win32.PAGE_WRITECOMBINE:
Protect += "W"
else:
Protect += "-"
# Type (file mapping, executable image, or private memory).
mbiType = mbi.Type
if mbiType == win32.MEM_IMAGE:
Type = "Image"
elif mbiType == win32.MEM_MAPPED:
Type = "Mapped"
elif mbiType == win32.MEM_PRIVATE:
Type = "Private"
elif mbiType == 0:
Type = ""
else:
Type = "Unknown"
# Output a row in the table.
if mappedFilenames:
FileName = mappedFilenames.get(mbi.BaseAddress, '')
table.addRow( BaseAddress, RegionSize, State, Protect, Type, FileName )
else:
table.addRow( BaseAddress, RegionSize, State, Protect, Type )
# Return the table output.
return table.getOutput()
#------------------------------------------------------------------------------
class DebugLog (StaticClass):
'Static functions for debug logging.'
@staticmethod
def log_text(text):
"""
Log lines of text, inserting a timestamp.
@type text: str
@param text: Text to log.
@rtype: str
@return: Log line.
"""
if text.endswith('\n'):
text = text[:-len('\n')]
#text = text.replace('\n', '\n\t\t') # text CSV
ltime = time.strftime("%X")
msecs = (time.time() % 1) * 1000
return '[%s.%04d] %s' % (ltime, msecs, text)
#return '[%s.%04d]\t%s' % (ltime, msecs, text) # text CSV
@classmethod
def log_event(cls, event, text = None):
"""
Log lines of text associated with a debug event.
@type event: L{Event}
@param event: Event object.
@type text: str
@param text: (Optional) Text to log. If no text is provided the default
is to show a description of the event itself.
@rtype: str
@return: Log line.
"""
if not text:
if event.get_event_code() == win32.EXCEPTION_DEBUG_EVENT:
what = event.get_exception_description()
if event.is_first_chance():
what = '%s (first chance)' % what
else:
what = '%s (second chance)' % what
try:
address = event.get_fault_address()
except NotImplementedError:
address = event.get_exception_address()
else:
what = event.get_event_name()
address = event.get_thread().get_pc()
process = event.get_process()
label = process.get_label_at_address(address)
address = HexDump.address(address, process.get_bits())
if label:
where = '%s (%s)' % (address, label)
else:
where = address
text = '%s at %s' % (what, where)
text = 'pid %d tid %d: %s' % (event.get_pid(), event.get_tid(), text)
#text = 'pid %d tid %d:\t%s' % (event.get_pid(), event.get_tid(), text) # text CSV
return cls.log_text(text)
#------------------------------------------------------------------------------
class Logger(object):
"""
Logs text to standard output and/or a text file.
@type logfile: str or None
@ivar logfile: Append messages to this text file.
@type verbose: bool
@ivar verbose: C{True} to print messages to standard output.
@type fd: file
@ivar fd: File object where log messages are printed to.
C{None} if no log file is used.
"""
def __init__(self, logfile = None, verbose = True):
"""
@type logfile: str or None
@param logfile: Append messages to this text file.
@type verbose: bool
@param verbose: C{True} to print messages to standard output.
"""
self.verbose = verbose
self.logfile = logfile
if self.logfile:
self.fd = open(self.logfile, 'a+')
def __logfile_error(self, e):
"""
Shows an error message to standard error
if the log file can't be written to.
Used internally.
@type e: Exception
@param e: Exception raised when trying to write to the log file.
"""
from sys import stderr
msg = "Warning, error writing log file %s: %s\n"
msg = msg % (self.logfile, str(e))
stderr.write(DebugLog.log_text(msg))
self.logfile = None
self.fd = None
def __do_log(self, text):
"""
Writes the given text verbatim into the log file (if any)
and/or standard input (if the verbose flag is turned on).
Used internally.
@type text: str
@param text: Text to print.
"""
if isinstance(text, compat.unicode):
text = text.encode('cp1252')
if self.verbose:
print(text)
if self.logfile:
try:
self.fd.writelines('%s\n' % text)
except IOError:
e = sys.exc_info()[1]
self.__logfile_error(e)
def log_text(self, text):
"""
Log lines of text, inserting a timestamp.
@type text: str
@param text: Text to log.
"""
self.__do_log( DebugLog.log_text(text) )
def log_event(self, event, text = None):
"""
Log lines of text associated with a debug event.
@type event: L{Event}
@param event: Event object.
@type text: str
@param text: (Optional) Text to log. If no text is provided the default
is to show a description of the event itself.
"""
self.__do_log( DebugLog.log_event(event, text) )
def log_exc(self):
"""
Log lines of text associated with the last Python exception.
"""
self.__do_log( 'Exception raised: %s' % traceback.format_exc() )
def is_enabled(self):
"""
Determines if the logger will actually print anything when the log_*
methods are called.
This may save some processing if the log text requires a lengthy
calculation to prepare. If no log file is set and stdout logging
is disabled, there's no point in preparing a log text that won't
be shown to anyone.
@rtype: bool
@return: C{True} if a log file was set and/or standard output logging
is enabled, or C{False} otherwise.
"""
return self.verbose or self.logfile
| apache-2.0 |
henrikju/resolve | response_approximation/UV_algorithm.py | 1 | 1388 | """
resolve.py
Written by Henrik Junklewitz based on scipts by Maksim Greiner
Resolve.py defines the main function that runs RESOLVE on a measurement
set with radio interferometric data.
Copyright 2016 Henrik Junklewitz
RESOLVE is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
RESOLVE is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with RESOLVE. If not, see <http://www.gnu.org/licenses/>.
"""
from nifty import *
from UV_classes import UV_quantities, lognormal_Hamiltonian
import time as ttt
def initialize_fastresolve(s_space, k_space, R, d, var):
return UV_quantities(domain=s_space, codomain=k_space, u=R.u,\
v=R.v, d=d, varis=var, A=R.A)
def resolve_to_fastresolve(fastresolve_operators):
"""
"""
return fastresolve_operators.get_dd(), fastresolve_operators.get_NN(),\
fastresolve_operators.get_RR()
def fastresolve_to_resolve(dorg, Rorg, Norg):
"""
"""
return dorg, Norg, Rorg
| gpl-2.0 |
mmagnus/rna-pdb-tools | rna_tools/tools/clarna_play/ClaRNAlib/bp_limits.py | 2 | 782660 | limits = {}
limits['HH_cis/AA/dist/100.00'] = {'max': 7.3753784439331627, 'min': 7.3613891466396524} # lost: 0
limits['HH_cis/AA/dist/95.00'] = {'max': 7.3753784439331627, 'min': 7.3613891466396524} # lost: 0
limits['HH_cis/AA/dist/99.00'] = {'max': 7.3753784439331627, 'min': 7.3613891466396524} # lost: 0
limits['HH_cis/AA/dist/99.50'] = {'max': 7.3753784439331627, 'min': 7.3613891466396524} # lost: 0
limits['HH_cis/AA/dist/99.90'] = {'max': 7.3753784439331627, 'min': 7.3613891466396524} # lost: 0
limits['HH_cis/AA/dist/99.99'] = {'max': 7.3753784439331627, 'min': 7.3613891466396524} # lost: 0
limits['HH_cis/AA/min_dist/100.00'] = {'max': 1.9208498354882761, 'min': 1.8975641556575249} # lost: 0
limits['HH_cis/AA/min_dist/95.00'] = {'max': 1.9208498354882761, 'min': 1.8975641556575249} # lost: 0
limits['HH_cis/AA/min_dist/99.00'] = {'max': 1.9208498354882761, 'min': 1.8975641556575249} # lost: 0
limits['HH_cis/AA/min_dist/99.50'] = {'max': 1.9208498354882761, 'min': 1.8975641556575249} # lost: 0
limits['HH_cis/AA/min_dist/99.90'] = {'max': 1.9208498354882761, 'min': 1.8975641556575249} # lost: 0
limits['HH_cis/AA/min_dist/99.99'] = {'max': 1.9208498354882761, 'min': 1.8975641556575249} # lost: 0
limits['HH_cis/AA/n2_z/100.00'] = {'max': -0.76924235, 'min': -0.77056342} # lost: 0
limits['HH_cis/AA/n2_z/95.00'] = {'max': -0.76924235, 'min': -0.77056342} # lost: 0
limits['HH_cis/AA/n2_z/99.00'] = {'max': -0.76924235, 'min': -0.77056342} # lost: 0
limits['HH_cis/AA/n2_z/99.50'] = {'max': -0.76924235, 'min': -0.77056342} # lost: 0
limits['HH_cis/AA/n2_z/99.90'] = {'max': -0.76924235, 'min': -0.77056342} # lost: 0
limits['HH_cis/AA/n2_z/99.99'] = {'max': -0.76924235, 'min': -0.77056342} # lost: 0
limits['HH_cis/AA/nn_ang_norm/100.00'] = {'max': 41.831980336407014, 'min': 39.68144063471513} # lost: 0
limits['HH_cis/AA/nn_ang_norm/95.00'] = {'max': 41.831980336407014, 'min': 39.68144063471513} # lost: 0
limits['HH_cis/AA/nn_ang_norm/99.00'] = {'max': 41.831980336407014, 'min': 39.68144063471513} # lost: 0
limits['HH_cis/AA/nn_ang_norm/99.50'] = {'max': 41.831980336407014, 'min': 39.68144063471513} # lost: 0
limits['HH_cis/AA/nn_ang_norm/99.90'] = {'max': 41.831980336407014, 'min': 39.68144063471513} # lost: 0
limits['HH_cis/AA/nn_ang_norm/99.99'] = {'max': 41.831980336407014, 'min': 39.68144063471513} # lost: 0
limits['HH_cis/AA/rot_ang/100.00'] = {'max': 256.96849758857832, 'min': 256.43351984175064} # lost: 0
limits['HH_cis/AA/rot_ang/95.00'] = {'max': 256.96849758857832, 'min': 256.43351984175064} # lost: 0
limits['HH_cis/AA/rot_ang/99.00'] = {'max': 256.96849758857832, 'min': 256.43351984175064} # lost: 0
limits['HH_cis/AA/rot_ang/99.50'] = {'max': 256.96849758857832, 'min': 256.43351984175064} # lost: 0
limits['HH_cis/AA/rot_ang/99.90'] = {'max': 256.96849758857832, 'min': 256.43351984175064} # lost: 0
limits['HH_cis/AA/rot_ang/99.99'] = {'max': 256.96849758857832, 'min': 256.43351984175064} # lost: 0
limits['HH_cis/AC/dist/100.00'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/AC/dist/95.00'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/AC/dist/99.00'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/AC/dist/99.50'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/AC/dist/99.90'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/AC/dist/99.99'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/AC/min_dist/100.00'] = {'max': 2.0801722074447118, 'min': 1.1963495828294726} # lost: 0
limits['HH_cis/AC/min_dist/95.00'] = {'max': 2.0801722074447118, 'min': 1.1963495828294726} # lost: 0
limits['HH_cis/AC/min_dist/99.00'] = {'max': 2.0801722074447118, 'min': 1.1963495828294726} # lost: 0
limits['HH_cis/AC/min_dist/99.50'] = {'max': 2.0801722074447118, 'min': 1.1963495828294726} # lost: 0
limits['HH_cis/AC/min_dist/99.90'] = {'max': 2.0801722074447118, 'min': 1.1963495828294726} # lost: 0
limits['HH_cis/AC/min_dist/99.99'] = {'max': 2.0801722074447118, 'min': 1.1963495828294726} # lost: 0
limits['HH_cis/AC/n2_z/100.00'] = {'max': -0.87957233, 'min': -0.99756181} # lost: 0
limits['HH_cis/AC/n2_z/95.00'] = {'max': -0.87957233, 'min': -0.99756181} # lost: 0
limits['HH_cis/AC/n2_z/99.00'] = {'max': -0.87957233, 'min': -0.99756181} # lost: 0
limits['HH_cis/AC/n2_z/99.50'] = {'max': -0.87957233, 'min': -0.99756181} # lost: 0
limits['HH_cis/AC/n2_z/99.90'] = {'max': -0.87957233, 'min': -0.99756181} # lost: 0
limits['HH_cis/AC/n2_z/99.99'] = {'max': -0.87957233, 'min': -0.99756181} # lost: 0
limits['HH_cis/AC/nn_ang_norm/100.00'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/AC/nn_ang_norm/95.00'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/AC/nn_ang_norm/99.00'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/AC/nn_ang_norm/99.50'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/AC/nn_ang_norm/99.90'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/AC/nn_ang_norm/99.99'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/AC/rot_ang/100.00'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AC/rot_ang/95.00'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AC/rot_ang/99.00'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AC/rot_ang/99.50'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AC/rot_ang/99.90'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AC/rot_ang/99.99'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AG/dist/100.00'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/AG/dist/95.00'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/AG/dist/99.00'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/AG/dist/99.50'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/AG/dist/99.90'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/AG/dist/99.99'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/AG/min_dist/100.00'] = {'max': 2.3758610869314967, 'min': 2.0539512736939152} # lost: 0
limits['HH_cis/AG/min_dist/95.00'] = {'max': 2.3758610869314967, 'min': 2.0539512736939152} # lost: 0
limits['HH_cis/AG/min_dist/99.00'] = {'max': 2.3758610869314967, 'min': 2.0539512736939152} # lost: 0
limits['HH_cis/AG/min_dist/99.50'] = {'max': 2.3758610869314967, 'min': 2.0539512736939152} # lost: 0
limits['HH_cis/AG/min_dist/99.90'] = {'max': 2.3758610869314967, 'min': 2.0539512736939152} # lost: 0
limits['HH_cis/AG/min_dist/99.99'] = {'max': 2.3758610869314967, 'min': 2.0539512736939152} # lost: 0
limits['HH_cis/AG/n2_z/100.00'] = {'max': -0.49982157, 'min': -0.82965237} # lost: 0
limits['HH_cis/AG/n2_z/95.00'] = {'max': -0.49982157, 'min': -0.82965237} # lost: 0
limits['HH_cis/AG/n2_z/99.00'] = {'max': -0.49982157, 'min': -0.82965237} # lost: 0
limits['HH_cis/AG/n2_z/99.50'] = {'max': -0.49982157, 'min': -0.82965237} # lost: 0
limits['HH_cis/AG/n2_z/99.90'] = {'max': -0.49982157, 'min': -0.82965237} # lost: 0
limits['HH_cis/AG/n2_z/99.99'] = {'max': -0.49982157, 'min': -0.82965237} # lost: 0
limits['HH_cis/AG/nn_ang_norm/100.00'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/AG/nn_ang_norm/95.00'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/AG/nn_ang_norm/99.00'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/AG/nn_ang_norm/99.50'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/AG/nn_ang_norm/99.90'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/AG/nn_ang_norm/99.99'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/AG/rot_ang/100.00'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AG/rot_ang/95.00'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AG/rot_ang/99.00'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AG/rot_ang/99.50'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AG/rot_ang/99.90'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AG/rot_ang/99.99'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AU/dist/100.00'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/AU/dist/95.00'] = {'max': 7.0592778575335391, 'min': 6.076381571398465} # lost: 2
limits['HH_cis/AU/dist/99.00'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/AU/dist/99.50'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/AU/dist/99.90'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/AU/dist/99.99'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/AU/min_dist/100.00'] = {'max': 2.0921529725345311, 'min': 1.2275933557220644} # lost: 0
limits['HH_cis/AU/min_dist/95.00'] = {'max': 2.0391526140683491, 'min': 1.2277059480341379} # lost: 2
limits['HH_cis/AU/min_dist/99.00'] = {'max': 2.0921529725345311, 'min': 1.2275933557220644} # lost: 0
limits['HH_cis/AU/min_dist/99.50'] = {'max': 2.0921529725345311, 'min': 1.2275933557220644} # lost: 0
limits['HH_cis/AU/min_dist/99.90'] = {'max': 2.0921529725345311, 'min': 1.2275933557220644} # lost: 0
limits['HH_cis/AU/min_dist/99.99'] = {'max': 2.0921529725345311, 'min': 1.2275933557220644} # lost: 0
limits['HH_cis/AU/n2_z/100.00'] = {'max': -0.42476833, 'min': -0.99233556} # lost: 0
limits['HH_cis/AU/n2_z/95.00'] = {'max': -0.42721498, 'min': -0.99233556} # lost: 2
limits['HH_cis/AU/n2_z/99.00'] = {'max': -0.42476833, 'min': -0.99233556} # lost: 0
limits['HH_cis/AU/n2_z/99.50'] = {'max': -0.42476833, 'min': -0.99233556} # lost: 0
limits['HH_cis/AU/n2_z/99.90'] = {'max': -0.42476833, 'min': -0.99233556} # lost: 0
limits['HH_cis/AU/n2_z/99.99'] = {'max': -0.42476833, 'min': -0.99233556} # lost: 0
limits['HH_cis/AU/nn_ang_norm/100.00'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/AU/nn_ang_norm/95.00'] = {'max': 64.543056005994742, 'min': 6.562194858781794} # lost: 2
limits['HH_cis/AU/nn_ang_norm/99.00'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/AU/nn_ang_norm/99.50'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/AU/nn_ang_norm/99.90'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/AU/nn_ang_norm/99.99'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/AU/rot_ang/100.00'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AU/rot_ang/95.00'] = {'max2': -83.543454326545145, 'min1': 250.00550977553797, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HH_cis/AU/rot_ang/99.00'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AU/rot_ang/99.50'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AU/rot_ang/99.90'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/AU/rot_ang/99.99'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CA/dist/100.00'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/CA/dist/95.00'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/CA/dist/99.00'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/CA/dist/99.50'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/CA/dist/99.90'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/CA/dist/99.99'] = {'max': 7.6703373819487792, 'min': 6.9687680529788505} # lost: 0
limits['HH_cis/CA/min_dist/100.00'] = {'max': 2.0801730474700477, 'min': 1.1963500219912333} # lost: 0
limits['HH_cis/CA/min_dist/95.00'] = {'max': 2.0801730474700477, 'min': 1.1963500219912333} # lost: 0
limits['HH_cis/CA/min_dist/99.00'] = {'max': 2.0801730474700477, 'min': 1.1963500219912333} # lost: 0
limits['HH_cis/CA/min_dist/99.50'] = {'max': 2.0801730474700477, 'min': 1.1963500219912333} # lost: 0
limits['HH_cis/CA/min_dist/99.90'] = {'max': 2.0801730474700477, 'min': 1.1963500219912333} # lost: 0
limits['HH_cis/CA/min_dist/99.99'] = {'max': 2.0801730474700477, 'min': 1.1963500219912333} # lost: 0
limits['HH_cis/CA/n2_z/100.00'] = {'max': -0.87957233, 'min': -0.99756175} # lost: 0
limits['HH_cis/CA/n2_z/95.00'] = {'max': -0.87957233, 'min': -0.99756175} # lost: 0
limits['HH_cis/CA/n2_z/99.00'] = {'max': -0.87957233, 'min': -0.99756175} # lost: 0
limits['HH_cis/CA/n2_z/99.50'] = {'max': -0.87957233, 'min': -0.99756175} # lost: 0
limits['HH_cis/CA/n2_z/99.90'] = {'max': -0.87957233, 'min': -0.99756175} # lost: 0
limits['HH_cis/CA/n2_z/99.99'] = {'max': -0.87957233, 'min': -0.99756175} # lost: 0
limits['HH_cis/CA/nn_ang_norm/100.00'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/CA/nn_ang_norm/95.00'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/CA/nn_ang_norm/99.00'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/CA/nn_ang_norm/99.50'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/CA/nn_ang_norm/99.90'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/CA/nn_ang_norm/99.99'] = {'max': 29.499349789896968, 'min': 3.2984709261612579} # lost: 0
limits['HH_cis/CA/rot_ang/100.00'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CA/rot_ang/95.00'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CA/rot_ang/99.00'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CA/rot_ang/99.50'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CA/rot_ang/99.90'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CA/rot_ang/99.99'] = {'max2': -80.502465790318865, 'min1': 239.17930425357071, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CG/dist/100.00'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/CG/dist/95.00'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/CG/dist/99.00'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/CG/dist/99.50'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/CG/dist/99.90'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/CG/dist/99.99'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/CG/min_dist/100.00'] = {'max': 2.2994168946237359, 'min': 1.6327578124416902} # lost: 0
limits['HH_cis/CG/min_dist/95.00'] = {'max': 2.2994168946237359, 'min': 1.6327578124416902} # lost: 0
limits['HH_cis/CG/min_dist/99.00'] = {'max': 2.2994168946237359, 'min': 1.6327578124416902} # lost: 0
limits['HH_cis/CG/min_dist/99.50'] = {'max': 2.2994168946237359, 'min': 1.6327578124416902} # lost: 0
limits['HH_cis/CG/min_dist/99.90'] = {'max': 2.2994168946237359, 'min': 1.6327578124416902} # lost: 0
limits['HH_cis/CG/min_dist/99.99'] = {'max': 2.2994168946237359, 'min': 1.6327578124416902} # lost: 0
limits['HH_cis/CG/n2_z/100.00'] = {'max': -0.89417952, 'min': -0.99991047} # lost: 0
limits['HH_cis/CG/n2_z/95.00'] = {'max': -0.89417952, 'min': -0.99991047} # lost: 0
limits['HH_cis/CG/n2_z/99.00'] = {'max': -0.89417952, 'min': -0.99991047} # lost: 0
limits['HH_cis/CG/n2_z/99.50'] = {'max': -0.89417952, 'min': -0.99991047} # lost: 0
limits['HH_cis/CG/n2_z/99.90'] = {'max': -0.89417952, 'min': -0.99991047} # lost: 0
limits['HH_cis/CG/n2_z/99.99'] = {'max': -0.89417952, 'min': -0.99991047} # lost: 0
limits['HH_cis/CG/nn_ang_norm/100.00'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/CG/nn_ang_norm/95.00'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/CG/nn_ang_norm/99.00'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/CG/nn_ang_norm/99.50'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/CG/nn_ang_norm/99.90'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/CG/nn_ang_norm/99.99'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/CG/rot_ang/100.00'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CG/rot_ang/95.00'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CG/rot_ang/99.00'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CG/rot_ang/99.50'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CG/rot_ang/99.90'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/CG/rot_ang/99.99'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GA/dist/100.00'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/GA/dist/95.00'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/GA/dist/99.00'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/GA/dist/99.50'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/GA/dist/99.90'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/GA/dist/99.99'] = {'max': 8.0092893528455793, 'min': 7.4038019012568634} # lost: 0
limits['HH_cis/GA/min_dist/100.00'] = {'max': 2.3758601828431289, 'min': 2.0539528872102686} # lost: 0
limits['HH_cis/GA/min_dist/95.00'] = {'max': 2.3758601828431289, 'min': 2.0539528872102686} # lost: 0
limits['HH_cis/GA/min_dist/99.00'] = {'max': 2.3758601828431289, 'min': 2.0539528872102686} # lost: 0
limits['HH_cis/GA/min_dist/99.50'] = {'max': 2.3758601828431289, 'min': 2.0539528872102686} # lost: 0
limits['HH_cis/GA/min_dist/99.90'] = {'max': 2.3758601828431289, 'min': 2.0539528872102686} # lost: 0
limits['HH_cis/GA/min_dist/99.99'] = {'max': 2.3758601828431289, 'min': 2.0539528872102686} # lost: 0
limits['HH_cis/GA/n2_z/100.00'] = {'max': -0.49982142, 'min': -0.82965219} # lost: 0
limits['HH_cis/GA/n2_z/95.00'] = {'max': -0.49982142, 'min': -0.82965219} # lost: 0
limits['HH_cis/GA/n2_z/99.00'] = {'max': -0.49982142, 'min': -0.82965219} # lost: 0
limits['HH_cis/GA/n2_z/99.50'] = {'max': -0.49982142, 'min': -0.82965219} # lost: 0
limits['HH_cis/GA/n2_z/99.90'] = {'max': -0.49982142, 'min': -0.82965219} # lost: 0
limits['HH_cis/GA/n2_z/99.99'] = {'max': -0.49982142, 'min': -0.82965219} # lost: 0
limits['HH_cis/GA/nn_ang_norm/100.00'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/GA/nn_ang_norm/95.00'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/GA/nn_ang_norm/99.00'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/GA/nn_ang_norm/99.50'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/GA/nn_ang_norm/99.90'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/GA/nn_ang_norm/99.99'] = {'max': 60.182267088886732, 'min': 27.700373585163987} # lost: 0
limits['HH_cis/GA/rot_ang/100.00'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GA/rot_ang/95.00'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GA/rot_ang/99.00'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GA/rot_ang/99.50'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GA/rot_ang/99.90'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GA/rot_ang/99.99'] = {'max2': -68.206318051420965, 'min1': 266.54447314317258, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GC/dist/100.00'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/GC/dist/95.00'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/GC/dist/99.00'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/GC/dist/99.50'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/GC/dist/99.90'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/GC/dist/99.99'] = {'max': 7.4976252737508533, 'min': 6.2850801469947815} # lost: 0
limits['HH_cis/GC/min_dist/100.00'] = {'max': 2.2994115636517454, 'min': 1.6327564431886152} # lost: 0
limits['HH_cis/GC/min_dist/95.00'] = {'max': 2.2994115636517454, 'min': 1.6327564431886152} # lost: 0
limits['HH_cis/GC/min_dist/99.00'] = {'max': 2.2994115636517454, 'min': 1.6327564431886152} # lost: 0
limits['HH_cis/GC/min_dist/99.50'] = {'max': 2.2994115636517454, 'min': 1.6327564431886152} # lost: 0
limits['HH_cis/GC/min_dist/99.90'] = {'max': 2.2994115636517454, 'min': 1.6327564431886152} # lost: 0
limits['HH_cis/GC/min_dist/99.99'] = {'max': 2.2994115636517454, 'min': 1.6327564431886152} # lost: 0
limits['HH_cis/GC/n2_z/100.00'] = {'max': -0.89417964, 'min': -0.99991047} # lost: 0
limits['HH_cis/GC/n2_z/95.00'] = {'max': -0.89417964, 'min': -0.99991047} # lost: 0
limits['HH_cis/GC/n2_z/99.00'] = {'max': -0.89417964, 'min': -0.99991047} # lost: 0
limits['HH_cis/GC/n2_z/99.50'] = {'max': -0.89417964, 'min': -0.99991047} # lost: 0
limits['HH_cis/GC/n2_z/99.90'] = {'max': -0.89417964, 'min': -0.99991047} # lost: 0
limits['HH_cis/GC/n2_z/99.99'] = {'max': -0.89417964, 'min': -0.99991047} # lost: 0
limits['HH_cis/GC/nn_ang_norm/100.00'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/GC/nn_ang_norm/95.00'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/GC/nn_ang_norm/99.00'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/GC/nn_ang_norm/99.50'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/GC/nn_ang_norm/99.90'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/GC/nn_ang_norm/99.99'] = {'max': 26.679902342029067, 'min': 0.86094033592377173} # lost: 0
limits['HH_cis/GC/rot_ang/100.00'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GC/rot_ang/95.00'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GC/rot_ang/99.00'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GC/rot_ang/99.50'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GC/rot_ang/99.90'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/GC/rot_ang/99.99'] = {'max2': -74.093298840876457, 'min1': 261.84913945344209, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/UA/dist/100.00'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/UA/dist/95.00'] = {'max': 7.0592778575335391, 'min': 6.076381571398465} # lost: 2
limits['HH_cis/UA/dist/99.00'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/UA/dist/99.50'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/UA/dist/99.90'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/UA/dist/99.99'] = {'max': 7.3315405943265688, 'min': 6.0736049015006133} # lost: 0
limits['HH_cis/UA/min_dist/100.00'] = {'max': 2.0921643898717956, 'min': 1.2275972948098528} # lost: 0
limits['HH_cis/UA/min_dist/95.00'] = {'max': 2.03915358391626, 'min': 1.227710603956637} # lost: 2
limits['HH_cis/UA/min_dist/99.00'] = {'max': 2.0921643898717956, 'min': 1.2275972948098528} # lost: 0
limits['HH_cis/UA/min_dist/99.50'] = {'max': 2.0921643898717956, 'min': 1.2275972948098528} # lost: 0
limits['HH_cis/UA/min_dist/99.90'] = {'max': 2.0921643898717956, 'min': 1.2275972948098528} # lost: 0
limits['HH_cis/UA/min_dist/99.99'] = {'max': 2.0921643898717956, 'min': 1.2275972948098528} # lost: 0
limits['HH_cis/UA/n2_z/100.00'] = {'max': -0.42476824, 'min': -0.99233568} # lost: 0
limits['HH_cis/UA/n2_z/95.00'] = {'max': -0.42721495, 'min': -0.99233568} # lost: 2
limits['HH_cis/UA/n2_z/99.00'] = {'max': -0.42476824, 'min': -0.99233568} # lost: 0
limits['HH_cis/UA/n2_z/99.50'] = {'max': -0.42476824, 'min': -0.99233568} # lost: 0
limits['HH_cis/UA/n2_z/99.90'] = {'max': -0.42476824, 'min': -0.99233568} # lost: 0
limits['HH_cis/UA/n2_z/99.99'] = {'max': -0.42476824, 'min': -0.99233568} # lost: 0
limits['HH_cis/UA/nn_ang_norm/100.00'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/UA/nn_ang_norm/95.00'] = {'max': 64.543056005994742, 'min': 6.562194858781794} # lost: 2
limits['HH_cis/UA/nn_ang_norm/99.00'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/UA/nn_ang_norm/99.50'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/UA/nn_ang_norm/99.90'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/UA/nn_ang_norm/99.99'] = {'max': 64.709753602878067, 'min': 6.562194858781794} # lost: 0
limits['HH_cis/UA/rot_ang/100.00'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/UA/rot_ang/95.00'] = {'max2': -83.543454326545145, 'min1': 250.00550977553797, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HH_cis/UA/rot_ang/99.00'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/UA/rot_ang/99.50'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/UA/rot_ang/99.90'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_cis/UA/rot_ang/99.99'] = {'max2': -83.463996404251247, 'min1': 236.04055331084027, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HH_tran/AA/dist/100.00'] = {'max': 8.1254855738515879, 'min': 6.5737606559928841} # lost: 0
limits['HH_tran/AA/dist/95.00'] = {'max': 7.768343848858728, 'min': 7.0441727816169353} # lost: 411
limits['HH_tran/AA/dist/99.00'] = {'max': 7.9200916765972806, 'min': 6.8536337829179272} # lost: 82
limits['HH_tran/AA/dist/99.50'] = {'max': 7.9749623321942407, 'min': 6.8030193949928295} # lost: 41
limits['HH_tran/AA/dist/99.90'] = {'max': 8.0524247880480786, 'min': 6.7249601657106846} # lost: 8
limits['HH_tran/AA/dist/99.99'] = {'max': 8.1254855738515879, 'min': 6.5737606559928841} # lost: 0
limits['HH_tran/AA/min_dist/100.00'] = {'max': 2.7646287674296195, 'min': 0.64722390147761011} # lost: 0
limits['HH_tran/AA/min_dist/95.00'] = {'max': 2.3612849225746348, 'min': 1.6888434017012162} # lost: 411
limits['HH_tran/AA/min_dist/99.00'] = {'max': 2.504983510547524, 'min': 1.5607517453718576} # lost: 82
limits['HH_tran/AA/min_dist/99.50'] = {'max': 2.564858438612923, 'min': 1.4921103502675042} # lost: 41
limits['HH_tran/AA/min_dist/99.90'] = {'max': 2.6528607932455919, 'min': 1.347098408909394} # lost: 8
limits['HH_tran/AA/min_dist/99.99'] = {'max': 2.7646287674296195, 'min': 0.64722390147761011} # lost: 0
limits['HH_tran/AA/n2_z/100.00'] = {'max': 0.99999499, 'min': 0.42449924} # lost: 0
limits['HH_tran/AA/n2_z/95.00'] = {'max': 0.99999499, 'min': 0.72845626} # lost: 411
limits['HH_tran/AA/n2_z/99.00'] = {'max': 0.99999499, 'min': 0.58690804} # lost: 82
limits['HH_tran/AA/n2_z/99.50'] = {'max': 0.99999499, 'min': 0.5060457} # lost: 41
limits['HH_tran/AA/n2_z/99.90'] = {'max': 0.99999499, 'min': 0.45310396} # lost: 8
limits['HH_tran/AA/n2_z/99.99'] = {'max': 0.99999499, 'min': 0.42449924} # lost: 0
limits['HH_tran/AA/nn_ang_norm/100.00'] = {'max': 64.562458752193905, 'min': 0.17358940449821952} # lost: 0
limits['HH_tran/AA/nn_ang_norm/95.00'] = {'max': 43.298003488436528, 'min': 0.17358940449821952} # lost: 411
limits['HH_tran/AA/nn_ang_norm/99.00'] = {'max': 54.255737445590519, 'min': 0.17358940449821952} # lost: 82
limits['HH_tran/AA/nn_ang_norm/99.50'] = {'max': 59.460095706330115, 'min': 0.17358940449821952} # lost: 41
limits['HH_tran/AA/nn_ang_norm/99.90'] = {'max': 62.653106690473521, 'min': 0.17358940449821952} # lost: 8
limits['HH_tran/AA/nn_ang_norm/99.99'] = {'max': 64.562458752193905, 'min': 0.17358940449821952} # lost: 0
limits['HH_tran/AA/rot_ang/100.00'] = {'max': 206.93843731186834, 'min': 153.06156268813166} # lost: 0
limits['HH_tran/AA/rot_ang/95.00'] = {'max': 194.04449196772973, 'min': 165.90748132276096} # lost: 411
limits['HH_tran/AA/rot_ang/99.00'] = {'max': 198.59477958385693, 'min': 161.40522041614307} # lost: 82
limits['HH_tran/AA/rot_ang/99.50'] = {'max': 200.27952343596957, 'min': 159.59842387115791} # lost: 41
limits['HH_tran/AA/rot_ang/99.90'] = {'max': 203.91999836647778, 'min': 156.08000163352222} # lost: 8
limits['HH_tran/AA/rot_ang/99.99'] = {'max': 206.93843731186834, 'min': 153.06156268813166} # lost: 0
limits['HH_tran/AC/dist/100.00'] = {'max': 7.8621597687099349, 'min': 5.7579116228382823} # lost: 0
limits['HH_tran/AC/dist/95.00'] = {'max': 7.2391475683483302, 'min': 6.1650618808443101} # lost: 10
limits['HH_tran/AC/dist/99.00'] = {'max': 7.3439514494225815, 'min': 6.0137919528671366} # lost: 2
limits['HH_tran/AC/dist/99.50'] = {'max': 7.3439514494225815, 'min': 5.7579116228382823} # lost: 1
limits['HH_tran/AC/dist/99.90'] = {'max': 7.8621597687099349, 'min': 5.7579116228382823} # lost: 0
limits['HH_tran/AC/dist/99.99'] = {'max': 7.8621597687099349, 'min': 5.7579116228382823} # lost: 0
limits['HH_tran/AC/min_dist/100.00'] = {'max': 2.4595702287620806, 'min': 0.61496776809543086} # lost: 0
limits['HH_tran/AC/min_dist/95.00'] = {'max': 2.2984817485748223, 'min': 0.71473739792400215} # lost: 10
limits['HH_tran/AC/min_dist/99.00'] = {'max': 2.3777800220589747, 'min': 0.61738866588292518} # lost: 2
limits['HH_tran/AC/min_dist/99.50'] = {'max': 2.3777800220589747, 'min': 0.61496776809543086} # lost: 1
limits['HH_tran/AC/min_dist/99.90'] = {'max': 2.4595702287620806, 'min': 0.61496776809543086} # lost: 0
limits['HH_tran/AC/min_dist/99.99'] = {'max': 2.4595702287620806, 'min': 0.61496776809543086} # lost: 0
limits['HH_tran/AC/n2_z/100.00'] = {'max': 0.99941301, 'min': 0.44363099} # lost: 0
limits['HH_tran/AC/n2_z/95.00'] = {'max': 0.99941301, 'min': 0.49679118} # lost: 10
limits['HH_tran/AC/n2_z/99.00'] = {'max': 0.99941301, 'min': 0.45870927} # lost: 2
limits['HH_tran/AC/n2_z/99.50'] = {'max': 0.99941301, 'min': 0.45410559} # lost: 1
limits['HH_tran/AC/n2_z/99.90'] = {'max': 0.99941301, 'min': 0.44363099} # lost: 0
limits['HH_tran/AC/n2_z/99.99'] = {'max': 0.99941301, 'min': 0.44363099} # lost: 0
limits['HH_tran/AC/nn_ang_norm/100.00'] = {'max': 64.548006071910166, 'min': 1.7182833893830958} # lost: 0
limits['HH_tran/AC/nn_ang_norm/95.00'] = {'max': 59.950428156656159, 'min': 1.7182833893830958} # lost: 10
limits['HH_tran/AC/nn_ang_norm/99.00'] = {'max': 63.636025553551718, 'min': 1.7182833893830958} # lost: 2
limits['HH_tran/AC/nn_ang_norm/99.50'] = {'max': 64.071866754679405, 'min': 1.7182833893830958} # lost: 1
limits['HH_tran/AC/nn_ang_norm/99.90'] = {'max': 64.548006071910166, 'min': 1.7182833893830958} # lost: 0
limits['HH_tran/AC/nn_ang_norm/99.99'] = {'max': 64.548006071910166, 'min': 1.7182833893830958} # lost: 0
limits['HH_tran/AC/rot_ang/100.00'] = {'max': 208.07462915456722, 'min': 160.32621639907086} # lost: 0
limits['HH_tran/AC/rot_ang/95.00'] = {'max': 202.88311726550475, 'min': 166.67951322728948} # lost: 10
limits['HH_tran/AC/rot_ang/99.00'] = {'max': 207.51888397218119, 'min': 160.48675931341413} # lost: 2
limits['HH_tran/AC/rot_ang/99.50'] = {'max': 207.51888397218119, 'min': 160.32621639907086} # lost: 1
limits['HH_tran/AC/rot_ang/99.90'] = {'max': 208.07462915456722, 'min': 160.32621639907086} # lost: 0
limits['HH_tran/AC/rot_ang/99.99'] = {'max': 208.07462915456722, 'min': 160.32621639907086} # lost: 0
limits['HH_tran/AG/dist/100.00'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/AG/dist/95.00'] = {'max': 7.717030528919067, 'min': 6.5496121522193684} # lost: 6
limits['HH_tran/AG/dist/99.00'] = {'max': 7.7265473617323597, 'min': 6.2882152906644251} # lost: 1
limits['HH_tran/AG/dist/99.50'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/AG/dist/99.90'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/AG/dist/99.99'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/AG/min_dist/100.00'] = {'max': 2.3890499971098826, 'min': 1.4530324469202738} # lost: 0
limits['HH_tran/AG/min_dist/95.00'] = {'max': 2.3661769934680246, 'min': 1.5586563245364677} # lost: 6
limits['HH_tran/AG/min_dist/99.00'] = {'max': 2.3799440750128547, 'min': 1.4530324469202738} # lost: 1
limits['HH_tran/AG/min_dist/99.50'] = {'max': 2.3890499971098826, 'min': 1.4530324469202738} # lost: 0
limits['HH_tran/AG/min_dist/99.90'] = {'max': 2.3890499971098826, 'min': 1.4530324469202738} # lost: 0
limits['HH_tran/AG/min_dist/99.99'] = {'max': 2.3890499971098826, 'min': 1.4530324469202738} # lost: 0
limits['HH_tran/AG/n2_z/100.00'] = {'max': 0.99153364, 'min': 0.4636752} # lost: 0
limits['HH_tran/AG/n2_z/95.00'] = {'max': 0.99153364, 'min': 0.59771764} # lost: 6
limits['HH_tran/AG/n2_z/99.00'] = {'max': 0.99153364, 'min': 0.46422103} # lost: 1
limits['HH_tran/AG/n2_z/99.50'] = {'max': 0.99153364, 'min': 0.4636752} # lost: 0
limits['HH_tran/AG/n2_z/99.90'] = {'max': 0.99153364, 'min': 0.4636752} # lost: 0
limits['HH_tran/AG/n2_z/99.99'] = {'max': 0.99153364, 'min': 0.4636752} # lost: 0
limits['HH_tran/AG/nn_ang_norm/100.00'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/AG/nn_ang_norm/95.00'] = {'max': 53.260479845776693, 'min': 7.4120359099332118} # lost: 6
limits['HH_tran/AG/nn_ang_norm/99.00'] = {'max': 62.342264781346245, 'min': 7.4120359099332118} # lost: 1
limits['HH_tran/AG/nn_ang_norm/99.50'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/AG/nn_ang_norm/99.90'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/AG/nn_ang_norm/99.99'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/AG/rot_ang/100.00'] = {'max': 225.48517162509611, 'min': 174.64536977788953} # lost: 0
limits['HH_tran/AG/rot_ang/95.00'] = {'max': 218.35468746945307, 'min': 184.52439247657929} # lost: 6
limits['HH_tran/AG/rot_ang/99.00'] = {'max': 219.634124669268, 'min': 174.64536977788953} # lost: 1
limits['HH_tran/AG/rot_ang/99.50'] = {'max': 225.48517162509611, 'min': 174.64536977788953} # lost: 0
limits['HH_tran/AG/rot_ang/99.90'] = {'max': 225.48517162509611, 'min': 174.64536977788953} # lost: 0
limits['HH_tran/AG/rot_ang/99.99'] = {'max': 225.48517162509611, 'min': 174.64536977788953} # lost: 0
limits['HH_tran/AU/dist/100.00'] = {'max': 8.0295101296635245, 'min': 6.2421707675053968} # lost: 0
limits['HH_tran/AU/dist/95.00'] = {'max': 7.8335991501296691, 'min': 6.9807024464658012} # lost: 13
limits['HH_tran/AU/dist/99.00'] = {'max': 7.8839854673659113, 'min': 6.2755851650776258} # lost: 2
limits['HH_tran/AU/dist/99.50'] = {'max': 7.8839854673659113, 'min': 6.2421707675053968} # lost: 1
limits['HH_tran/AU/dist/99.90'] = {'max': 8.0295101296635245, 'min': 6.2421707675053968} # lost: 0
limits['HH_tran/AU/dist/99.99'] = {'max': 8.0295101296635245, 'min': 6.2421707675053968} # lost: 0
limits['HH_tran/AU/min_dist/100.00'] = {'max': 2.6096124406497809, 'min': 0.8116511734930042} # lost: 0
limits['HH_tran/AU/min_dist/95.00'] = {'max': 2.3466748525262489, 'min': 1.6452464640145468} # lost: 13
limits['HH_tran/AU/min_dist/99.00'] = {'max': 2.5586100107431289, 'min': 0.830882061178568} # lost: 2
limits['HH_tran/AU/min_dist/99.50'] = {'max': 2.5586100107431289, 'min': 0.8116511734930042} # lost: 1
limits['HH_tran/AU/min_dist/99.90'] = {'max': 2.6096124406497809, 'min': 0.8116511734930042} # lost: 0
limits['HH_tran/AU/min_dist/99.99'] = {'max': 2.6096124406497809, 'min': 0.8116511734930042} # lost: 0
limits['HH_tran/AU/n2_z/100.00'] = {'max': 0.99098778, 'min': 0.78719789} # lost: 0
limits['HH_tran/AU/n2_z/95.00'] = {'max': 0.99098778, 'min': 0.83404475} # lost: 13
limits['HH_tran/AU/n2_z/99.00'] = {'max': 0.99098778, 'min': 0.79867333} # lost: 2
limits['HH_tran/AU/n2_z/99.50'] = {'max': 0.99098778, 'min': 0.78983295} # lost: 1
limits['HH_tran/AU/n2_z/99.90'] = {'max': 0.99098778, 'min': 0.78719789} # lost: 0
limits['HH_tran/AU/n2_z/99.99'] = {'max': 0.99098778, 'min': 0.78719789} # lost: 0
limits['HH_tran/AU/nn_ang_norm/100.00'] = {'max': 40.335275747254684, 'min': 7.0979069722678636} # lost: 0
limits['HH_tran/AU/nn_ang_norm/95.00'] = {'max': 33.820607165950676, 'min': 7.0979069722678636} # lost: 13
limits['HH_tran/AU/nn_ang_norm/99.00'] = {'max': 38.166758987667336, 'min': 7.0979069722678636} # lost: 2
limits['HH_tran/AU/nn_ang_norm/99.50'] = {'max': 40.108428089445638, 'min': 7.0979069722678636} # lost: 1
limits['HH_tran/AU/nn_ang_norm/99.90'] = {'max': 40.335275747254684, 'min': 7.0979069722678636} # lost: 0
limits['HH_tran/AU/nn_ang_norm/99.99'] = {'max': 40.335275747254684, 'min': 7.0979069722678636} # lost: 0
limits['HH_tran/AU/rot_ang/100.00'] = {'max': 219.59479253641547, 'min': 177.42457384572864} # lost: 0
limits['HH_tran/AU/rot_ang/95.00'] = {'max': 205.99369478865128, 'min': 186.78071953957647} # lost: 13
limits['HH_tran/AU/rot_ang/99.00'] = {'max': 212.30469046731605, 'min': 182.67189420406945} # lost: 2
limits['HH_tran/AU/rot_ang/99.50'] = {'max': 212.30469046731605, 'min': 177.42457384572864} # lost: 1
limits['HH_tran/AU/rot_ang/99.90'] = {'max': 219.59479253641547, 'min': 177.42457384572864} # lost: 0
limits['HH_tran/AU/rot_ang/99.99'] = {'max': 219.59479253641547, 'min': 177.42457384572864} # lost: 0
limits['HH_tran/CA/dist/100.00'] = {'max': 7.8621597687099349, 'min': 5.7579116228382823} # lost: 0
limits['HH_tran/CA/dist/95.00'] = {'max': 7.2391475683483302, 'min': 6.1650618808443101} # lost: 10
limits['HH_tran/CA/dist/99.00'] = {'max': 7.3439514494225815, 'min': 6.0137919528671366} # lost: 2
limits['HH_tran/CA/dist/99.50'] = {'max': 7.3439514494225815, 'min': 5.7579116228382823} # lost: 1
limits['HH_tran/CA/dist/99.90'] = {'max': 7.8621597687099349, 'min': 5.7579116228382823} # lost: 0
limits['HH_tran/CA/dist/99.99'] = {'max': 7.8621597687099349, 'min': 5.7579116228382823} # lost: 0
limits['HH_tran/CA/min_dist/100.00'] = {'max': 2.4595684744445689, 'min': 0.61496717162550474} # lost: 0
limits['HH_tran/CA/min_dist/95.00'] = {'max': 2.2984824372615655, 'min': 0.7147256819766078} # lost: 10
limits['HH_tran/CA/min_dist/99.00'] = {'max': 2.377780393345966, 'min': 0.61738702505675758} # lost: 2
limits['HH_tran/CA/min_dist/99.50'] = {'max': 2.377780393345966, 'min': 0.61496717162550474} # lost: 1
limits['HH_tran/CA/min_dist/99.90'] = {'max': 2.4595684744445689, 'min': 0.61496717162550474} # lost: 0
limits['HH_tran/CA/min_dist/99.99'] = {'max': 2.4595684744445689, 'min': 0.61496717162550474} # lost: 0
limits['HH_tran/CA/n2_z/100.00'] = {'max': 0.99941301, 'min': 0.44363108} # lost: 0
limits['HH_tran/CA/n2_z/95.00'] = {'max': 0.99941301, 'min': 0.49679118} # lost: 10
limits['HH_tran/CA/n2_z/99.00'] = {'max': 0.99941301, 'min': 0.4587093} # lost: 2
limits['HH_tran/CA/n2_z/99.50'] = {'max': 0.99941301, 'min': 0.45410588} # lost: 1
limits['HH_tran/CA/n2_z/99.90'] = {'max': 0.99941301, 'min': 0.44363108} # lost: 0
limits['HH_tran/CA/n2_z/99.99'] = {'max': 0.99941301, 'min': 0.44363108} # lost: 0
limits['HH_tran/CA/nn_ang_norm/100.00'] = {'max': 64.548006071910166, 'min': 1.7182833893830958} # lost: 0
limits['HH_tran/CA/nn_ang_norm/95.00'] = {'max': 59.950428156656159, 'min': 1.7182833893830958} # lost: 10
limits['HH_tran/CA/nn_ang_norm/99.00'] = {'max': 63.636025553551718, 'min': 1.7182833893830958} # lost: 2
limits['HH_tran/CA/nn_ang_norm/99.50'] = {'max': 64.071866754679405, 'min': 1.7182833893830958} # lost: 1
limits['HH_tran/CA/nn_ang_norm/99.90'] = {'max': 64.548006071910166, 'min': 1.7182833893830958} # lost: 0
limits['HH_tran/CA/nn_ang_norm/99.99'] = {'max': 64.548006071910166, 'min': 1.7182833893830958} # lost: 0
limits['HH_tran/CA/rot_ang/100.00'] = {'max': 199.67378360092914, 'min': 151.92537084543278} # lost: 0
limits['HH_tran/CA/rot_ang/95.00'] = {'max': 193.32048677271052, 'min': 157.11688273449525} # lost: 10
limits['HH_tran/CA/rot_ang/99.00'] = {'max': 199.51324068658587, 'min': 152.48111602781881} # lost: 2
limits['HH_tran/CA/rot_ang/99.50'] = {'max': 199.51324068658587, 'min': 151.92537084543278} # lost: 1
limits['HH_tran/CA/rot_ang/99.90'] = {'max': 199.67378360092914, 'min': 151.92537084543278} # lost: 0
limits['HH_tran/CA/rot_ang/99.99'] = {'max': 199.67378360092914, 'min': 151.92537084543278} # lost: 0
limits['HH_tran/CC/dist/100.00'] = {'max': 7.3378467485276655, 'min': 7.3378467485276655} # lost: 0
limits['HH_tran/CC/dist/95.00'] = {'max': 7.3378467485276655, 'min': 7.3378467485276655} # lost: 0
limits['HH_tran/CC/dist/99.00'] = {'max': 7.3378467485276655, 'min': 7.3378467485276655} # lost: 0
limits['HH_tran/CC/dist/99.50'] = {'max': 7.3378467485276655, 'min': 7.3378467485276655} # lost: 0
limits['HH_tran/CC/dist/99.90'] = {'max': 7.3378467485276655, 'min': 7.3378467485276655} # lost: 0
limits['HH_tran/CC/dist/99.99'] = {'max': 7.3378467485276655, 'min': 7.3378467485276655} # lost: 0
limits['HH_tran/CC/min_dist/100.00'] = {'max': 1.8505723383766386, 'min': 1.8505666743189373} # lost: 0
limits['HH_tran/CC/min_dist/95.00'] = {'max': 1.8505723383766386, 'min': 1.8505666743189373} # lost: 0
limits['HH_tran/CC/min_dist/99.00'] = {'max': 1.8505723383766386, 'min': 1.8505666743189373} # lost: 0
limits['HH_tran/CC/min_dist/99.50'] = {'max': 1.8505723383766386, 'min': 1.8505666743189373} # lost: 0
limits['HH_tran/CC/min_dist/99.90'] = {'max': 1.8505723383766386, 'min': 1.8505666743189373} # lost: 0
limits['HH_tran/CC/min_dist/99.99'] = {'max': 1.8505723383766386, 'min': 1.8505666743189373} # lost: 0
limits['HH_tran/CC/n2_z/100.00'] = {'max': 0.9991349, 'min': 0.9991349} # lost: 0
limits['HH_tran/CC/n2_z/95.00'] = {'max': 0.9991349, 'min': 0.9991349} # lost: 0
limits['HH_tran/CC/n2_z/99.00'] = {'max': 0.9991349, 'min': 0.9991349} # lost: 0
limits['HH_tran/CC/n2_z/99.50'] = {'max': 0.9991349, 'min': 0.9991349} # lost: 0
limits['HH_tran/CC/n2_z/99.90'] = {'max': 0.9991349, 'min': 0.9991349} # lost: 0
limits['HH_tran/CC/n2_z/99.99'] = {'max': 0.9991349, 'min': 0.9991349} # lost: 0
limits['HH_tran/CC/nn_ang_norm/100.00'] = {'max': 6.9039603356907664, 'min': 6.9039603356907664} # lost: 0
limits['HH_tran/CC/nn_ang_norm/95.00'] = {'max': 6.9039603356907664, 'min': 6.9039603356907664} # lost: 0
limits['HH_tran/CC/nn_ang_norm/99.00'] = {'max': 6.9039603356907664, 'min': 6.9039603356907664} # lost: 0
limits['HH_tran/CC/nn_ang_norm/99.50'] = {'max': 6.9039603356907664, 'min': 6.9039603356907664} # lost: 0
limits['HH_tran/CC/nn_ang_norm/99.90'] = {'max': 6.9039603356907664, 'min': 6.9039603356907664} # lost: 0
limits['HH_tran/CC/nn_ang_norm/99.99'] = {'max': 6.9039603356907664, 'min': 6.9039603356907664} # lost: 0
limits['HH_tran/CC/rot_ang/100.00'] = {'max': 189.27717752364347, 'min': 170.72282247635653} # lost: 0
limits['HH_tran/CC/rot_ang/95.00'] = {'max': 189.27717752364347, 'min': 170.72282247635653} # lost: 0
limits['HH_tran/CC/rot_ang/99.00'] = {'max': 189.27717752364347, 'min': 170.72282247635653} # lost: 0
limits['HH_tran/CC/rot_ang/99.50'] = {'max': 189.27717752364347, 'min': 170.72282247635653} # lost: 0
limits['HH_tran/CC/rot_ang/99.90'] = {'max': 189.27717752364347, 'min': 170.72282247635653} # lost: 0
limits['HH_tran/CC/rot_ang/99.99'] = {'max': 189.27717752364347, 'min': 170.72282247635653} # lost: 0
limits['HH_tran/CG/dist/100.00'] = {'max': 7.6615256086475316, 'min': 5.7213330703902505} # lost: 0
limits['HH_tran/CG/dist/95.00'] = {'max': 7.505138360730319, 'min': 6.6276409390122817} # lost: 17
limits['HH_tran/CG/dist/99.00'] = {'max': 7.5988555788394478, 'min': 6.066628944489211} # lost: 3
limits['HH_tran/CG/dist/99.50'] = {'max': 7.6350462749494294, 'min': 5.7213330703902505} # lost: 1
limits['HH_tran/CG/dist/99.90'] = {'max': 7.6615256086475316, 'min': 5.7213330703902505} # lost: 0
limits['HH_tran/CG/dist/99.99'] = {'max': 7.6615256086475316, 'min': 5.7213330703902505} # lost: 0
limits['HH_tran/CG/min_dist/100.00'] = {'max': 2.5579019540412666, 'min': 1.0742479384704624} # lost: 0
limits['HH_tran/CG/min_dist/95.00'] = {'max': 2.3770790444536214, 'min': 1.569313136012604} # lost: 17
limits['HH_tran/CG/min_dist/99.00'] = {'max': 2.474870904070579, 'min': 1.4750349018179714} # lost: 3
limits['HH_tran/CG/min_dist/99.50'] = {'max': 2.5270783147585441, 'min': 1.0742479384704624} # lost: 1
limits['HH_tran/CG/min_dist/99.90'] = {'max': 2.5579019540412666, 'min': 1.0742479384704624} # lost: 0
limits['HH_tran/CG/min_dist/99.99'] = {'max': 2.5579019540412666, 'min': 1.0742479384704624} # lost: 0
limits['HH_tran/CG/n2_z/100.00'] = {'max': 0.99840665, 'min': 0.42530528} # lost: 0
limits['HH_tran/CG/n2_z/95.00'] = {'max': 0.99840665, 'min': 0.79027033} # lost: 17
limits['HH_tran/CG/n2_z/99.00'] = {'max': 0.99840665, 'min': 0.70602733} # lost: 3
limits['HH_tran/CG/n2_z/99.50'] = {'max': 0.99840665, 'min': 0.43795142} # lost: 1
limits['HH_tran/CG/n2_z/99.90'] = {'max': 0.99840665, 'min': 0.42530528} # lost: 0
limits['HH_tran/CG/n2_z/99.99'] = {'max': 0.99840665, 'min': 0.42530528} # lost: 0
limits['HH_tran/CG/nn_ang_norm/100.00'] = {'max': 64.338216811553224, 'min': 2.9158451092754669} # lost: 0
limits['HH_tran/CG/nn_ang_norm/95.00'] = {'max': 37.711421011553853, 'min': 2.9158451092754669} # lost: 17
limits['HH_tran/CG/nn_ang_norm/99.00'] = {'max': 43.99947074638601, 'min': 2.9158451092754669} # lost: 3
limits['HH_tran/CG/nn_ang_norm/99.50'] = {'max': 64.180767290806088, 'min': 2.9158451092754669} # lost: 1
limits['HH_tran/CG/nn_ang_norm/99.90'] = {'max': 64.338216811553224, 'min': 2.9158451092754669} # lost: 0
limits['HH_tran/CG/nn_ang_norm/99.99'] = {'max': 64.338216811553224, 'min': 2.9158451092754669} # lost: 0
limits['HH_tran/CG/rot_ang/100.00'] = {'max': 211.67576935972446, 'min': 151.28946117829634} # lost: 0
limits['HH_tran/CG/rot_ang/95.00'] = {'max': 199.27243536737362, 'min': 158.34480746369712} # lost: 17
limits['HH_tran/CG/rot_ang/99.00'] = {'max': 203.23725136540168, 'min': 151.66772526585657} # lost: 3
limits['HH_tran/CG/rot_ang/99.50'] = {'max': 209.440629211925, 'min': 151.28946117829634} # lost: 1
limits['HH_tran/CG/rot_ang/99.90'] = {'max': 211.67576935972446, 'min': 151.28946117829634} # lost: 0
limits['HH_tran/CG/rot_ang/99.99'] = {'max': 211.67576935972446, 'min': 151.28946117829634} # lost: 0
limits['HH_tran/CU/dist/100.00'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/CU/dist/95.00'] = {'max': 7.4888474921801116, 'min': 6.6576724759878365} # lost: 8
limits['HH_tran/CU/dist/99.00'] = {'max': 7.5461343661129501, 'min': 6.4836350570584198} # lost: 1
limits['HH_tran/CU/dist/99.50'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/CU/dist/99.90'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/CU/dist/99.99'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/CU/min_dist/100.00'] = {'max': 2.4799792432050185, 'min': 1.3999409761921522} # lost: 0
limits['HH_tran/CU/min_dist/95.00'] = {'max': 2.381718603696219, 'min': 1.5215403615318743} # lost: 8
limits['HH_tran/CU/min_dist/99.00'] = {'max': 2.456592694038624, 'min': 1.3999409761921522} # lost: 1
limits['HH_tran/CU/min_dist/99.50'] = {'max': 2.4799792432050185, 'min': 1.3999409761921522} # lost: 0
limits['HH_tran/CU/min_dist/99.90'] = {'max': 2.4799792432050185, 'min': 1.3999409761921522} # lost: 0
limits['HH_tran/CU/min_dist/99.99'] = {'max': 2.4799792432050185, 'min': 1.3999409761921522} # lost: 0
limits['HH_tran/CU/n2_z/100.00'] = {'max': 0.98680872, 'min': 0.59952641} # lost: 0
limits['HH_tran/CU/n2_z/95.00'] = {'max': 0.98680872, 'min': 0.81327009} # lost: 8
limits['HH_tran/CU/n2_z/99.00'] = {'max': 0.98680872, 'min': 0.73165673} # lost: 1
limits['HH_tran/CU/n2_z/99.50'] = {'max': 0.98680872, 'min': 0.59952641} # lost: 0
limits['HH_tran/CU/n2_z/99.90'] = {'max': 0.98680872, 'min': 0.59952641} # lost: 0
limits['HH_tran/CU/n2_z/99.99'] = {'max': 0.98680872, 'min': 0.59952641} # lost: 0
limits['HH_tran/CU/nn_ang_norm/100.00'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/CU/nn_ang_norm/95.00'] = {'max': 35.519213740830317, 'min': 8.4419669650686053} # lost: 8
limits['HH_tran/CU/nn_ang_norm/99.00'] = {'max': 42.933213330149904, 'min': 8.4419669650686053} # lost: 1
limits['HH_tran/CU/nn_ang_norm/99.50'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/CU/nn_ang_norm/99.90'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/CU/nn_ang_norm/99.99'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/CU/rot_ang/100.00'] = {'max': 203.68767734723579, 'min': 172.40235075126404} # lost: 0
limits['HH_tran/CU/rot_ang/95.00'] = {'max': 201.1448852797071, 'min': 179.0272634853423} # lost: 8
limits['HH_tran/CU/rot_ang/99.00'] = {'max': 202.14156243864531, 'min': 172.40235075126404} # lost: 1
limits['HH_tran/CU/rot_ang/99.50'] = {'max': 203.68767734723579, 'min': 172.40235075126404} # lost: 0
limits['HH_tran/CU/rot_ang/99.90'] = {'max': 203.68767734723579, 'min': 172.40235075126404} # lost: 0
limits['HH_tran/CU/rot_ang/99.99'] = {'max': 203.68767734723579, 'min': 172.40235075126404} # lost: 0
limits['HH_tran/GA/dist/100.00'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/GA/dist/95.00'] = {'max': 7.717030528919067, 'min': 6.5496121522193684} # lost: 6
limits['HH_tran/GA/dist/99.00'] = {'max': 7.7265473617323597, 'min': 6.2882152906644251} # lost: 1
limits['HH_tran/GA/dist/99.50'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/GA/dist/99.90'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/GA/dist/99.99'] = {'max': 7.8156732362049954, 'min': 6.2882152906644251} # lost: 0
limits['HH_tran/GA/min_dist/100.00'] = {'max': 2.3890488217820662, 'min': 1.4530449604786879} # lost: 0
limits['HH_tran/GA/min_dist/95.00'] = {'max': 2.3661751169389138, 'min': 1.5586511387117081} # lost: 6
limits['HH_tran/GA/min_dist/99.00'] = {'max': 2.3799487806379238, 'min': 1.4530449604786879} # lost: 1
limits['HH_tran/GA/min_dist/99.50'] = {'max': 2.3890488217820662, 'min': 1.4530449604786879} # lost: 0
limits['HH_tran/GA/min_dist/99.90'] = {'max': 2.3890488217820662, 'min': 1.4530449604786879} # lost: 0
limits['HH_tran/GA/min_dist/99.99'] = {'max': 2.3890488217820662, 'min': 1.4530449604786879} # lost: 0
limits['HH_tran/GA/n2_z/100.00'] = {'max': 0.99153364, 'min': 0.46367541} # lost: 0
limits['HH_tran/GA/n2_z/95.00'] = {'max': 0.99153364, 'min': 0.5977177} # lost: 6
limits['HH_tran/GA/n2_z/99.00'] = {'max': 0.99153364, 'min': 0.46422115} # lost: 1
limits['HH_tran/GA/n2_z/99.50'] = {'max': 0.99153364, 'min': 0.46367541} # lost: 0
limits['HH_tran/GA/n2_z/99.90'] = {'max': 0.99153364, 'min': 0.46367541} # lost: 0
limits['HH_tran/GA/n2_z/99.99'] = {'max': 0.99153364, 'min': 0.46367541} # lost: 0
limits['HH_tran/GA/nn_ang_norm/100.00'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/GA/nn_ang_norm/95.00'] = {'max': 53.260479845776693, 'min': 7.4120359099332118} # lost: 6
limits['HH_tran/GA/nn_ang_norm/99.00'] = {'max': 62.342264781346245, 'min': 7.4120359099332118} # lost: 1
limits['HH_tran/GA/nn_ang_norm/99.50'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/GA/nn_ang_norm/99.90'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/GA/nn_ang_norm/99.99'] = {'max': 62.526024190776269, 'min': 7.4120359099332118} # lost: 0
limits['HH_tran/GA/rot_ang/100.00'] = {'max': 185.35463022211047, 'min': 134.51482837490389} # lost: 0
limits['HH_tran/GA/rot_ang/95.00'] = {'max': 175.47560752342071, 'min': 141.64531253054693} # lost: 6
limits['HH_tran/GA/rot_ang/99.00'] = {'max': 184.99386032333746, 'min': 134.51482837490389} # lost: 1
limits['HH_tran/GA/rot_ang/99.50'] = {'max': 185.35463022211047, 'min': 134.51482837490389} # lost: 0
limits['HH_tran/GA/rot_ang/99.90'] = {'max': 185.35463022211047, 'min': 134.51482837490389} # lost: 0
limits['HH_tran/GA/rot_ang/99.99'] = {'max': 185.35463022211047, 'min': 134.51482837490389} # lost: 0
limits['HH_tran/GC/dist/100.00'] = {'max': 7.6615256086475316, 'min': 5.7213330703902505} # lost: 0
limits['HH_tran/GC/dist/95.00'] = {'max': 7.505138360730319, 'min': 6.6276409390122817} # lost: 17
limits['HH_tran/GC/dist/99.00'] = {'max': 7.5988555788394478, 'min': 6.066628944489211} # lost: 3
limits['HH_tran/GC/dist/99.50'] = {'max': 7.6350462749494294, 'min': 5.7213330703902505} # lost: 1
limits['HH_tran/GC/dist/99.90'] = {'max': 7.6615256086475316, 'min': 5.7213330703902505} # lost: 0
limits['HH_tran/GC/dist/99.99'] = {'max': 7.6615256086475316, 'min': 5.7213330703902505} # lost: 0
limits['HH_tran/GC/min_dist/100.00'] = {'max': 2.5578949354796396, 'min': 1.0742496110197202} # lost: 0
limits['HH_tran/GC/min_dist/95.00'] = {'max': 2.3771040011140236, 'min': 1.5693020455421434} # lost: 17
limits['HH_tran/GC/min_dist/99.00'] = {'max': 2.4748445911501467, 'min': 1.4750342789107325} # lost: 3
limits['HH_tran/GC/min_dist/99.50'] = {'max': 2.5270857579012818, 'min': 1.0742496110197202} # lost: 1
limits['HH_tran/GC/min_dist/99.90'] = {'max': 2.5578949354796396, 'min': 1.0742496110197202} # lost: 0
limits['HH_tran/GC/min_dist/99.99'] = {'max': 2.5578949354796396, 'min': 1.0742496110197202} # lost: 0
limits['HH_tran/GC/n2_z/100.00'] = {'max': 0.99840665, 'min': 0.42530534} # lost: 0
limits['HH_tran/GC/n2_z/95.00'] = {'max': 0.99840665, 'min': 0.79027027} # lost: 17
limits['HH_tran/GC/n2_z/99.00'] = {'max': 0.99840665, 'min': 0.70602733} # lost: 3
limits['HH_tran/GC/n2_z/99.50'] = {'max': 0.99840665, 'min': 0.43795156} # lost: 1
limits['HH_tran/GC/n2_z/99.90'] = {'max': 0.99840665, 'min': 0.42530534} # lost: 0
limits['HH_tran/GC/n2_z/99.99'] = {'max': 0.99840665, 'min': 0.42530534} # lost: 0
limits['HH_tran/GC/nn_ang_norm/100.00'] = {'max': 64.338216811553224, 'min': 2.9158451092754669} # lost: 0
limits['HH_tran/GC/nn_ang_norm/95.00'] = {'max': 37.711421011553853, 'min': 2.9158451092754669} # lost: 17
limits['HH_tran/GC/nn_ang_norm/99.00'] = {'max': 43.99947074638601, 'min': 2.9158451092754669} # lost: 3
limits['HH_tran/GC/nn_ang_norm/99.50'] = {'max': 64.180767290806088, 'min': 2.9158451092754669} # lost: 1
limits['HH_tran/GC/nn_ang_norm/99.90'] = {'max': 64.338216811553224, 'min': 2.9158451092754669} # lost: 0
limits['HH_tran/GC/nn_ang_norm/99.99'] = {'max': 64.338216811553224, 'min': 2.9158451092754669} # lost: 0
limits['HH_tran/GC/rot_ang/100.00'] = {'max': 208.71053882170366, 'min': 148.32423064027554} # lost: 0
limits['HH_tran/GC/rot_ang/95.00'] = {'max': 201.63662284965926, 'min': 160.5372005052391} # lost: 17
limits['HH_tran/GC/rot_ang/99.00'] = {'max': 207.43324215793371, 'min': 150.559370788075} # lost: 3
limits['HH_tran/GC/rot_ang/99.50'] = {'max': 208.33227473414343, 'min': 148.32423064027554} # lost: 1
limits['HH_tran/GC/rot_ang/99.90'] = {'max': 208.71053882170366, 'min': 148.32423064027554} # lost: 0
limits['HH_tran/GC/rot_ang/99.99'] = {'max': 208.71053882170366, 'min': 148.32423064027554} # lost: 0
limits['HH_tran/GG/dist/100.00'] = {'max': 7.4718242159749559, 'min': 7.4718242159749559} # lost: 0
limits['HH_tran/GG/dist/95.00'] = {'max': 7.4718242159749559, 'min': 7.4718242159749559} # lost: 0
limits['HH_tran/GG/dist/99.00'] = {'max': 7.4718242159749559, 'min': 7.4718242159749559} # lost: 0
limits['HH_tran/GG/dist/99.50'] = {'max': 7.4718242159749559, 'min': 7.4718242159749559} # lost: 0
limits['HH_tran/GG/dist/99.90'] = {'max': 7.4718242159749559, 'min': 7.4718242159749559} # lost: 0
limits['HH_tran/GG/dist/99.99'] = {'max': 7.4718242159749559, 'min': 7.4718242159749559} # lost: 0
limits['HH_tran/GG/min_dist/100.00'] = {'max': 2.9091394546697291, 'min': 2.9091323628537715} # lost: 0
limits['HH_tran/GG/min_dist/95.00'] = {'max': 2.9091394546697291, 'min': 2.9091323628537715} # lost: 0
limits['HH_tran/GG/min_dist/99.00'] = {'max': 2.9091394546697291, 'min': 2.9091323628537715} # lost: 0
limits['HH_tran/GG/min_dist/99.50'] = {'max': 2.9091394546697291, 'min': 2.9091323628537715} # lost: 0
limits['HH_tran/GG/min_dist/99.90'] = {'max': 2.9091394546697291, 'min': 2.9091323628537715} # lost: 0
limits['HH_tran/GG/min_dist/99.99'] = {'max': 2.9091394546697291, 'min': 2.9091323628537715} # lost: 0
limits['HH_tran/GG/n2_z/100.00'] = {'max': 0.99994904, 'min': 0.99994904} # lost: 0
limits['HH_tran/GG/n2_z/95.00'] = {'max': 0.99994904, 'min': 0.99994904} # lost: 0
limits['HH_tran/GG/n2_z/99.00'] = {'max': 0.99994904, 'min': 0.99994904} # lost: 0
limits['HH_tran/GG/n2_z/99.50'] = {'max': 0.99994904, 'min': 0.99994904} # lost: 0
limits['HH_tran/GG/n2_z/99.90'] = {'max': 0.99994904, 'min': 0.99994904} # lost: 0
limits['HH_tran/GG/n2_z/99.99'] = {'max': 0.99994904, 'min': 0.99994904} # lost: 0
limits['HH_tran/GG/nn_ang_norm/100.00'] = {'max': 0.86727837098373717, 'min': 0.86727837098373717} # lost: 0
limits['HH_tran/GG/nn_ang_norm/95.00'] = {'max': 0.86727837098373717, 'min': 0.86727837098373717} # lost: 0
limits['HH_tran/GG/nn_ang_norm/99.00'] = {'max': 0.86727837098373717, 'min': 0.86727837098373717} # lost: 0
limits['HH_tran/GG/nn_ang_norm/99.50'] = {'max': 0.86727837098373717, 'min': 0.86727837098373717} # lost: 0
limits['HH_tran/GG/nn_ang_norm/99.90'] = {'max': 0.86727837098373717, 'min': 0.86727837098373717} # lost: 0
limits['HH_tran/GG/nn_ang_norm/99.99'] = {'max': 0.86727837098373717, 'min': 0.86727837098373717} # lost: 0
limits['HH_tran/GG/rot_ang/100.00'] = {'max': 180.73741265096248, 'min': 179.26258734903752} # lost: 0
limits['HH_tran/GG/rot_ang/95.00'] = {'max': 180.73741265096248, 'min': 179.26258734903752} # lost: 0
limits['HH_tran/GG/rot_ang/99.00'] = {'max': 180.73741265096248, 'min': 179.26258734903752} # lost: 0
limits['HH_tran/GG/rot_ang/99.50'] = {'max': 180.73741265096248, 'min': 179.26258734903752} # lost: 0
limits['HH_tran/GG/rot_ang/99.90'] = {'max': 180.73741265096248, 'min': 179.26258734903752} # lost: 0
limits['HH_tran/GG/rot_ang/99.99'] = {'max': 180.73741265096248, 'min': 179.26258734903752} # lost: 0
limits['HH_tran/UA/dist/100.00'] = {'max': 8.0295101296635245, 'min': 6.2421707675053968} # lost: 0
limits['HH_tran/UA/dist/95.00'] = {'max': 7.8335991501296691, 'min': 6.9807024464658012} # lost: 13
limits['HH_tran/UA/dist/99.00'] = {'max': 7.8839854673659113, 'min': 6.2755851650776258} # lost: 2
limits['HH_tran/UA/dist/99.50'] = {'max': 7.8839854673659113, 'min': 6.2421707675053968} # lost: 1
limits['HH_tran/UA/dist/99.90'] = {'max': 8.0295101296635245, 'min': 6.2421707675053968} # lost: 0
limits['HH_tran/UA/dist/99.99'] = {'max': 8.0295101296635245, 'min': 6.2421707675053968} # lost: 0
limits['HH_tran/UA/min_dist/100.00'] = {'max': 2.6096146198257988, 'min': 0.81163670603995908} # lost: 0
limits['HH_tran/UA/min_dist/95.00'] = {'max': 2.3466702513525184, 'min': 1.6452435833063417} # lost: 13
limits['HH_tran/UA/min_dist/99.00'] = {'max': 2.5585952842763291, 'min': 0.83088029306937439} # lost: 2
limits['HH_tran/UA/min_dist/99.50'] = {'max': 2.5585952842763291, 'min': 0.81163670603995908} # lost: 1
limits['HH_tran/UA/min_dist/99.90'] = {'max': 2.6096146198257988, 'min': 0.81163670603995908} # lost: 0
limits['HH_tran/UA/min_dist/99.99'] = {'max': 2.6096146198257988, 'min': 0.81163670603995908} # lost: 0
limits['HH_tran/UA/n2_z/100.00'] = {'max': 0.99098772, 'min': 0.78719789} # lost: 0
limits['HH_tran/UA/n2_z/95.00'] = {'max': 0.99098772, 'min': 0.83404481} # lost: 13
limits['HH_tran/UA/n2_z/99.00'] = {'max': 0.99098772, 'min': 0.79867351} # lost: 2
limits['HH_tran/UA/n2_z/99.50'] = {'max': 0.99098772, 'min': 0.78983301} # lost: 1
limits['HH_tran/UA/n2_z/99.90'] = {'max': 0.99098772, 'min': 0.78719789} # lost: 0
limits['HH_tran/UA/n2_z/99.99'] = {'max': 0.99098772, 'min': 0.78719789} # lost: 0
limits['HH_tran/UA/nn_ang_norm/100.00'] = {'max': 40.335275747254684, 'min': 7.0979069722678636} # lost: 0
limits['HH_tran/UA/nn_ang_norm/95.00'] = {'max': 33.820607165950676, 'min': 7.0979069722678636} # lost: 13
limits['HH_tran/UA/nn_ang_norm/99.00'] = {'max': 38.166758987667336, 'min': 7.0979069722678636} # lost: 2
limits['HH_tran/UA/nn_ang_norm/99.50'] = {'max': 40.108428089445638, 'min': 7.0979069722678636} # lost: 1
limits['HH_tran/UA/nn_ang_norm/99.90'] = {'max': 40.335275747254684, 'min': 7.0979069722678636} # lost: 0
limits['HH_tran/UA/nn_ang_norm/99.99'] = {'max': 40.335275747254684, 'min': 7.0979069722678636} # lost: 0
limits['HH_tran/UA/rot_ang/100.00'] = {'max': 182.57542615427136, 'min': 140.40520746358453} # lost: 0
limits['HH_tran/UA/rot_ang/95.00'] = {'max': 173.02767067422198, 'min': 153.54602986251442} # lost: 13
limits['HH_tran/UA/rot_ang/99.00'] = {'max': 177.32810579593055, 'min': 147.69530953268395} # lost: 2
limits['HH_tran/UA/rot_ang/99.50'] = {'max': 177.32810579593055, 'min': 140.40520746358453} # lost: 1
limits['HH_tran/UA/rot_ang/99.90'] = {'max': 182.57542615427136, 'min': 140.40520746358453} # lost: 0
limits['HH_tran/UA/rot_ang/99.99'] = {'max': 182.57542615427136, 'min': 140.40520746358453} # lost: 0
limits['HH_tran/UC/dist/100.00'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/UC/dist/95.00'] = {'max': 7.4888474921801116, 'min': 6.6576724759878365} # lost: 8
limits['HH_tran/UC/dist/99.00'] = {'max': 7.5461343661129501, 'min': 6.4836350570584198} # lost: 1
limits['HH_tran/UC/dist/99.50'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/UC/dist/99.90'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/UC/dist/99.99'] = {'max': 7.61697870540561, 'min': 6.4836350570584198} # lost: 0
limits['HH_tran/UC/min_dist/100.00'] = {'max': 2.4799847705353053, 'min': 1.3999546683629547} # lost: 0
limits['HH_tran/UC/min_dist/95.00'] = {'max': 2.3817206405514981, 'min': 1.5215417949084393} # lost: 8
limits['HH_tran/UC/min_dist/99.00'] = {'max': 2.4565836268336949, 'min': 1.3999546683629547} # lost: 1
limits['HH_tran/UC/min_dist/99.50'] = {'max': 2.4799847705353053, 'min': 1.3999546683629547} # lost: 0
limits['HH_tran/UC/min_dist/99.90'] = {'max': 2.4799847705353053, 'min': 1.3999546683629547} # lost: 0
limits['HH_tran/UC/min_dist/99.99'] = {'max': 2.4799847705353053, 'min': 1.3999546683629547} # lost: 0
limits['HH_tran/UC/n2_z/100.00'] = {'max': 0.98680866, 'min': 0.59952635} # lost: 0
limits['HH_tran/UC/n2_z/95.00'] = {'max': 0.98680866, 'min': 0.81327003} # lost: 8
limits['HH_tran/UC/n2_z/99.00'] = {'max': 0.98680866, 'min': 0.73165661} # lost: 1
limits['HH_tran/UC/n2_z/99.50'] = {'max': 0.98680866, 'min': 0.59952635} # lost: 0
limits['HH_tran/UC/n2_z/99.90'] = {'max': 0.98680866, 'min': 0.59952635} # lost: 0
limits['HH_tran/UC/n2_z/99.99'] = {'max': 0.98680866, 'min': 0.59952635} # lost: 0
limits['HH_tran/UC/nn_ang_norm/100.00'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/UC/nn_ang_norm/95.00'] = {'max': 35.519213740830317, 'min': 8.4419669650686053} # lost: 8
limits['HH_tran/UC/nn_ang_norm/99.00'] = {'max': 42.933213330149904, 'min': 8.4419669650686053} # lost: 1
limits['HH_tran/UC/nn_ang_norm/99.50'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/UC/nn_ang_norm/99.90'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/UC/nn_ang_norm/99.99'] = {'max': 44.516317991070046, 'min': 8.4419669650686053} # lost: 0
limits['HH_tran/UC/rot_ang/100.00'] = {'max': 187.59764924873596, 'min': 156.31232265276421} # lost: 0
limits['HH_tran/UC/rot_ang/95.00'] = {'max': 180.9727365146577, 'min': 158.8551147202929} # lost: 8
limits['HH_tran/UC/rot_ang/99.00'] = {'max': 187.4738572596244, 'min': 156.31232265276421} # lost: 1
limits['HH_tran/UC/rot_ang/99.50'] = {'max': 187.59764924873596, 'min': 156.31232265276421} # lost: 0
limits['HH_tran/UC/rot_ang/99.90'] = {'max': 187.59764924873596, 'min': 156.31232265276421} # lost: 0
limits['HH_tran/UC/rot_ang/99.99'] = {'max': 187.59764924873596, 'min': 156.31232265276421} # lost: 0
limits['HS_cis/AA/dist/100.00'] = {'max': 7.2734486264790643, 'min': 6.0401432364464993} # lost: 0
limits['HS_cis/AA/dist/95.00'] = {'max': 7.0792412283118455, 'min': 6.310055800903033} # lost: 43
limits['HS_cis/AA/dist/99.00'] = {'max': 7.1732548918851649, 'min': 6.2108820950972623} # lost: 8
limits['HS_cis/AA/dist/99.50'] = {'max': 7.2050976980790553, 'min': 6.191231068220679} # lost: 4
limits['HS_cis/AA/dist/99.90'] = {'max': 7.2734486264790643, 'min': 6.0401432364464993} # lost: 0
limits['HS_cis/AA/dist/99.99'] = {'max': 7.2734486264790643, 'min': 6.0401432364464993} # lost: 0
limits['HS_cis/AA/min_dist/100.00'] = {'max': 2.6209858980469063, 'min': 1.1749082980240997} # lost: 0
limits['HS_cis/AA/min_dist/95.00'] = {'max': 2.4357718532310182, 'min': 1.7602774009445405} # lost: 43
limits['HS_cis/AA/min_dist/99.00'] = {'max': 2.5397541980657832, 'min': 1.5907544644790783} # lost: 8
limits['HS_cis/AA/min_dist/99.50'] = {'max': 2.5484452497560492, 'min': 1.4676624212996101} # lost: 4
limits['HS_cis/AA/min_dist/99.90'] = {'max': 2.6209858980469063, 'min': 1.1749082980240997} # lost: 0
limits['HS_cis/AA/min_dist/99.99'] = {'max': 2.6209858980469063, 'min': 1.1749082980240997} # lost: 0
limits['HS_cis/AA/n2_z/100.00'] = {'max': 0.99993384, 'min': 0.42615518} # lost: 0
limits['HS_cis/AA/n2_z/95.00'] = {'max': 0.99993384, 'min': 0.60578263} # lost: 43
limits['HS_cis/AA/n2_z/99.00'] = {'max': 0.99993384, 'min': 0.44327444} # lost: 8
limits['HS_cis/AA/n2_z/99.50'] = {'max': 0.99993384, 'min': 0.43651485} # lost: 4
limits['HS_cis/AA/n2_z/99.90'] = {'max': 0.99993384, 'min': 0.42615518} # lost: 0
limits['HS_cis/AA/n2_z/99.99'] = {'max': 0.99993384, 'min': 0.42615518} # lost: 0
limits['HS_cis/AA/nn_ang_norm/100.00'] = {'max': 64.950563761212379, 'min': 0.48213889136467464} # lost: 0
limits['HS_cis/AA/nn_ang_norm/95.00'] = {'max': 52.581562457372009, 'min': 0.48213889136467464} # lost: 43
limits['HS_cis/AA/nn_ang_norm/99.00'] = {'max': 63.930379386022587, 'min': 0.48213889136467464} # lost: 8
limits['HS_cis/AA/nn_ang_norm/99.50'] = {'max': 64.306367639453455, 'min': 0.48213889136467464} # lost: 4
limits['HS_cis/AA/nn_ang_norm/99.90'] = {'max': 64.950563761212379, 'min': 0.48213889136467464} # lost: 0
limits['HS_cis/AA/nn_ang_norm/99.99'] = {'max': 64.950563761212379, 'min': 0.48213889136467464} # lost: 0
limits['HS_cis/AA/rot_ang/100.00'] = {'max': 50.409115140002605, 'min': -66.86282522282383} # lost: 0
limits['HS_cis/AA/rot_ang/95.00'] = {'max': 30.241708112011388, 'min': -62.52620907016675} # lost: 43
limits['HS_cis/AA/rot_ang/99.00'] = {'max': 41.808248048549594, 'min': -64.838059473594413} # lost: 8
limits['HS_cis/AA/rot_ang/99.50'] = {'max': 42.649062419662016, 'min': -65.133476004140192} # lost: 4
limits['HS_cis/AA/rot_ang/99.90'] = {'max': 50.409115140002605, 'min': -66.86282522282383} # lost: 0
limits['HS_cis/AA/rot_ang/99.99'] = {'max': 50.409115140002605, 'min': -66.86282522282383} # lost: 0
limits['HS_cis/AC/dist/100.00'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['HS_cis/AC/dist/95.00'] = {'max': 8.0470644404376621, 'min': 7.0820862929844912} # lost: 5
limits['HS_cis/AC/dist/99.00'] = {'max': 8.1756319103011155, 'min': 7.0431558855584955} # lost: 1
limits['HS_cis/AC/dist/99.50'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['HS_cis/AC/dist/99.90'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['HS_cis/AC/dist/99.99'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['HS_cis/AC/min_dist/100.00'] = {'max': 2.4428125646404184, 'min': 1.5222645191071857} # lost: 0
limits['HS_cis/AC/min_dist/95.00'] = {'max': 2.4332191190661963, 'min': 1.5457135508250275} # lost: 5
limits['HS_cis/AC/min_dist/99.00'] = {'max': 2.4356808784934558, 'min': 1.5222645191071857} # lost: 1
limits['HS_cis/AC/min_dist/99.50'] = {'max': 2.4428125646404184, 'min': 1.5222645191071857} # lost: 0
limits['HS_cis/AC/min_dist/99.90'] = {'max': 2.4428125646404184, 'min': 1.5222645191071857} # lost: 0
limits['HS_cis/AC/min_dist/99.99'] = {'max': 2.4428125646404184, 'min': 1.5222645191071857} # lost: 0
limits['HS_cis/AC/n2_z/100.00'] = {'max': 0.99312347, 'min': 0.49190837} # lost: 0
limits['HS_cis/AC/n2_z/95.00'] = {'max': 0.99312347, 'min': 0.58383918} # lost: 5
limits['HS_cis/AC/n2_z/99.00'] = {'max': 0.99312347, 'min': 0.49255645} # lost: 1
limits['HS_cis/AC/n2_z/99.50'] = {'max': 0.99312347, 'min': 0.49190837} # lost: 0
limits['HS_cis/AC/n2_z/99.90'] = {'max': 0.99312347, 'min': 0.49190837} # lost: 0
limits['HS_cis/AC/n2_z/99.99'] = {'max': 0.99312347, 'min': 0.49190837} # lost: 0
limits['HS_cis/AC/nn_ang_norm/100.00'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['HS_cis/AC/nn_ang_norm/95.00'] = {'max': 54.125093002241101, 'min': 6.6184097632863965} # lost: 5
limits['HS_cis/AC/nn_ang_norm/99.00'] = {'max': 60.215405345506802, 'min': 6.6184097632863965} # lost: 1
limits['HS_cis/AC/nn_ang_norm/99.50'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['HS_cis/AC/nn_ang_norm/99.90'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['HS_cis/AC/nn_ang_norm/99.99'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['HS_cis/AC/rot_ang/100.00'] = {'max': 44.034730620421591, 'min': -62.552800567610674} # lost: 0
limits['HS_cis/AC/rot_ang/95.00'] = {'max': 36.535420446262137, 'min': -62.094574585952799} # lost: 5
limits['HS_cis/AC/rot_ang/99.00'] = {'max': 41.267154571833011, 'min': -62.552800567610674} # lost: 1
limits['HS_cis/AC/rot_ang/99.50'] = {'max': 44.034730620421591, 'min': -62.552800567610674} # lost: 0
limits['HS_cis/AC/rot_ang/99.90'] = {'max': 44.034730620421591, 'min': -62.552800567610674} # lost: 0
limits['HS_cis/AC/rot_ang/99.99'] = {'max': 44.034730620421591, 'min': -62.552800567610674} # lost: 0
limits['HS_cis/AG/dist/100.00'] = {'max': 8.0474746668053569, 'min': 6.2974806011590827} # lost: 0
limits['HS_cis/AG/dist/95.00'] = {'max': 7.6911476646377475, 'min': 6.4922229132104734} # lost: 20
limits['HS_cis/AG/dist/99.00'] = {'max': 7.913851279243624, 'min': 6.3337426798914187} # lost: 4
limits['HS_cis/AG/dist/99.50'] = {'max': 7.9995659131035488, 'min': 6.3011088031617177} # lost: 2
limits['HS_cis/AG/dist/99.90'] = {'max': 8.0474746668053569, 'min': 6.2974806011590827} # lost: 0
limits['HS_cis/AG/dist/99.99'] = {'max': 8.0474746668053569, 'min': 6.2974806011590827} # lost: 0
limits['HS_cis/AG/min_dist/100.00'] = {'max': 2.5837698915432279, 'min': 0.44494433754359825} # lost: 0
limits['HS_cis/AG/min_dist/95.00'] = {'max': 2.3709629670838592, 'min': 1.2449997893091818} # lost: 20
limits['HS_cis/AG/min_dist/99.00'] = {'max': 2.5114691447230326, 'min': 0.97924758484464491} # lost: 4
limits['HS_cis/AG/min_dist/99.50'] = {'max': 2.5687338674924773, 'min': 0.85339535818790158} # lost: 2
limits['HS_cis/AG/min_dist/99.90'] = {'max': 2.5837698915432279, 'min': 0.44494433754359825} # lost: 0
limits['HS_cis/AG/min_dist/99.99'] = {'max': 2.5837698915432279, 'min': 0.44494433754359825} # lost: 0
limits['HS_cis/AG/n2_z/100.00'] = {'max': 0.99974871, 'min': 0.43494609} # lost: 0
limits['HS_cis/AG/n2_z/95.00'] = {'max': 0.99974871, 'min': 0.60834551} # lost: 20
limits['HS_cis/AG/n2_z/99.00'] = {'max': 0.99974871, 'min': 0.45711559} # lost: 4
limits['HS_cis/AG/n2_z/99.50'] = {'max': 0.99974871, 'min': 0.44777629} # lost: 2
limits['HS_cis/AG/n2_z/99.90'] = {'max': 0.99974871, 'min': 0.43494609} # lost: 0
limits['HS_cis/AG/n2_z/99.99'] = {'max': 0.99974871, 'min': 0.43494609} # lost: 0
limits['HS_cis/AG/nn_ang_norm/100.00'] = {'max': 63.934853159928949, 'min': 1.1691884737499034} # lost: 0
limits['HS_cis/AG/nn_ang_norm/95.00'] = {'max': 52.822814984140621, 'min': 1.1691884737499034} # lost: 20
limits['HS_cis/AG/nn_ang_norm/99.00'] = {'max': 62.516830756153432, 'min': 1.1691884737499034} # lost: 4
limits['HS_cis/AG/nn_ang_norm/99.50'] = {'max': 63.214643862896949, 'min': 1.1691884737499034} # lost: 2
limits['HS_cis/AG/nn_ang_norm/99.90'] = {'max': 63.934853159928949, 'min': 1.1691884737499034} # lost: 0
limits['HS_cis/AG/nn_ang_norm/99.99'] = {'max': 63.934853159928949, 'min': 1.1691884737499034} # lost: 0
limits['HS_cis/AG/rot_ang/100.00'] = {'max': 78.281166807908775, 'min': -64.770032249991388} # lost: 0
limits['HS_cis/AG/rot_ang/95.00'] = {'max': 61.675749575231563, 'min': -53.404360788312978} # lost: 20
limits['HS_cis/AG/rot_ang/99.00'] = {'max': 70.383244953955781, 'min': -64.037782861260382} # lost: 4
limits['HS_cis/AG/rot_ang/99.50'] = {'max': 70.865649799681265, 'min': -64.232241347008667} # lost: 2
limits['HS_cis/AG/rot_ang/99.90'] = {'max': 78.281166807908775, 'min': -64.770032249991388} # lost: 0
limits['HS_cis/AG/rot_ang/99.99'] = {'max': 78.281166807908775, 'min': -64.770032249991388} # lost: 0
limits['HS_cis/AU/dist/100.00'] = {'max': 8.3350646691989034, 'min': 7.0080591806791839} # lost: 0
limits['HS_cis/AU/dist/95.00'] = {'max': 8.1586119301311424, 'min': 7.28593105037986} # lost: 12
limits['HS_cis/AU/dist/99.00'] = {'max': 8.2800495599262049, 'min': 7.0214459681797035} # lost: 2
limits['HS_cis/AU/dist/99.50'] = {'max': 8.2800495599262049, 'min': 7.0080591806791839} # lost: 1
limits['HS_cis/AU/dist/99.90'] = {'max': 8.3350646691989034, 'min': 7.0080591806791839} # lost: 0
limits['HS_cis/AU/dist/99.99'] = {'max': 8.3350646691989034, 'min': 7.0080591806791839} # lost: 0
limits['HS_cis/AU/min_dist/100.00'] = {'max': 2.5106070775100626, 'min': 1.565833986574823} # lost: 0
limits['HS_cis/AU/min_dist/95.00'] = {'max': 2.42043662683938, 'min': 1.7741708868567116} # lost: 12
limits['HS_cis/AU/min_dist/99.00'] = {'max': 2.5088072761710749, 'min': 1.7061051368160915} # lost: 2
limits['HS_cis/AU/min_dist/99.50'] = {'max': 2.5088072761710749, 'min': 1.565833986574823} # lost: 1
limits['HS_cis/AU/min_dist/99.90'] = {'max': 2.5106070775100626, 'min': 1.565833986574823} # lost: 0
limits['HS_cis/AU/min_dist/99.99'] = {'max': 2.5106070775100626, 'min': 1.565833986574823} # lost: 0
limits['HS_cis/AU/n2_z/100.00'] = {'max': 0.98764145, 'min': 0.47720364} # lost: 0
limits['HS_cis/AU/n2_z/95.00'] = {'max': 0.98764145, 'min': 0.57959694} # lost: 12
limits['HS_cis/AU/n2_z/99.00'] = {'max': 0.98764145, 'min': 0.52861106} # lost: 2
limits['HS_cis/AU/n2_z/99.50'] = {'max': 0.98764145, 'min': 0.50268859} # lost: 1
limits['HS_cis/AU/n2_z/99.90'] = {'max': 0.98764145, 'min': 0.47720364} # lost: 0
limits['HS_cis/AU/n2_z/99.99'] = {'max': 0.98764145, 'min': 0.47720364} # lost: 0
limits['HS_cis/AU/nn_ang_norm/100.00'] = {'max': 61.387725354269449, 'min': 7.2266714060482364} # lost: 0
limits['HS_cis/AU/nn_ang_norm/95.00'] = {'max': 55.065145598088293, 'min': 7.2266714060482364} # lost: 12
limits['HS_cis/AU/nn_ang_norm/99.00'] = {'max': 58.218729315247806, 'min': 7.2266714060482364} # lost: 2
limits['HS_cis/AU/nn_ang_norm/99.50'] = {'max': 60.522709216644017, 'min': 7.2266714060482364} # lost: 1
limits['HS_cis/AU/nn_ang_norm/99.90'] = {'max': 61.387725354269449, 'min': 7.2266714060482364} # lost: 0
limits['HS_cis/AU/nn_ang_norm/99.99'] = {'max': 61.387725354269449, 'min': 7.2266714060482364} # lost: 0
limits['HS_cis/AU/rot_ang/100.00'] = {'max': 49.819591683506694, 'min': -62.401207036455368} # lost: 0
limits['HS_cis/AU/rot_ang/95.00'] = {'max': 27.149982615640649, 'min': -56.641063369380717} # lost: 12
limits['HS_cis/AU/rot_ang/99.00'] = {'max': 34.700409202546567, 'min': -60.714473516216444} # lost: 2
limits['HS_cis/AU/rot_ang/99.50'] = {'max': 34.700409202546567, 'min': -62.401207036455368} # lost: 1
limits['HS_cis/AU/rot_ang/99.90'] = {'max': 49.819591683506694, 'min': -62.401207036455368} # lost: 0
limits['HS_cis/AU/rot_ang/99.99'] = {'max': 49.819591683506694, 'min': -62.401207036455368} # lost: 0
limits['HS_cis/CA/dist/100.00'] = {'max': 7.0978163103048404, 'min': 5.8205611387670464} # lost: 0
limits['HS_cis/CA/dist/95.00'] = {'max': 6.9231173330934039, 'min': 5.9129147499167747} # lost: 15
limits['HS_cis/CA/dist/99.00'] = {'max': 6.9772710818839414, 'min': 5.8264379983139056} # lost: 3
limits['HS_cis/CA/dist/99.50'] = {'max': 7.0091616235151832, 'min': 5.8205611387670464} # lost: 1
limits['HS_cis/CA/dist/99.90'] = {'max': 7.0978163103048404, 'min': 5.8205611387670464} # lost: 0
limits['HS_cis/CA/dist/99.99'] = {'max': 7.0978163103048404, 'min': 5.8205611387670464} # lost: 0
limits['HS_cis/CA/min_dist/100.00'] = {'max': 2.5374424510993827, 'min': 1.2377192968610722} # lost: 0
limits['HS_cis/CA/min_dist/95.00'] = {'max': 2.4669693504200345, 'min': 1.7201958952708949} # lost: 15
limits['HS_cis/CA/min_dist/99.00'] = {'max': 2.518352150205327, 'min': 1.2387383186778271} # lost: 3
limits['HS_cis/CA/min_dist/99.50'] = {'max': 2.5188677986835408, 'min': 1.2377192968610722} # lost: 1
limits['HS_cis/CA/min_dist/99.90'] = {'max': 2.5374424510993827, 'min': 1.2377192968610722} # lost: 0
limits['HS_cis/CA/min_dist/99.99'] = {'max': 2.5374424510993827, 'min': 1.2377192968610722} # lost: 0
limits['HS_cis/CA/n2_z/100.00'] = {'max': 0.99983472, 'min': 0.46589479} # lost: 0
limits['HS_cis/CA/n2_z/95.00'] = {'max': 0.99983472, 'min': 0.80668104} # lost: 15
limits['HS_cis/CA/n2_z/99.00'] = {'max': 0.99983472, 'min': 0.59106034} # lost: 3
limits['HS_cis/CA/n2_z/99.50'] = {'max': 0.99983472, 'min': 0.47789279} # lost: 1
limits['HS_cis/CA/n2_z/99.90'] = {'max': 0.99983472, 'min': 0.46589479} # lost: 0
limits['HS_cis/CA/n2_z/99.99'] = {'max': 0.99983472, 'min': 0.46589479} # lost: 0
limits['HS_cis/CA/nn_ang_norm/100.00'] = {'max': 61.717985491207081, 'min': 1.0061934797269538} # lost: 0
limits['HS_cis/CA/nn_ang_norm/95.00'] = {'max': 36.624095876822842, 'min': 1.0061934797269538} # lost: 15
limits['HS_cis/CA/nn_ang_norm/99.00'] = {'max': 53.332569077371595, 'min': 1.0061934797269538} # lost: 3
limits['HS_cis/CA/nn_ang_norm/99.50'] = {'max': 60.047553446653737, 'min': 1.0061934797269538} # lost: 1
limits['HS_cis/CA/nn_ang_norm/99.90'] = {'max': 61.717985491207081, 'min': 1.0061934797269538} # lost: 0
limits['HS_cis/CA/nn_ang_norm/99.99'] = {'max': 61.717985491207081, 'min': 1.0061934797269538} # lost: 0
limits['HS_cis/CA/rot_ang/100.00'] = {'max': 61.563761249840162, 'min': -66.185754738727965} # lost: 0
limits['HS_cis/CA/rot_ang/95.00'] = {'max': 35.184895741846795, 'min': -46.679899636308278} # lost: 15
limits['HS_cis/CA/rot_ang/99.00'] = {'max': 40.494506167492382, 'min': -62.30455966018615} # lost: 3
limits['HS_cis/CA/rot_ang/99.50'] = {'max': 50.666386110339509, 'min': -66.185754738727965} # lost: 1
limits['HS_cis/CA/rot_ang/99.90'] = {'max': 61.563761249840162, 'min': -66.185754738727965} # lost: 0
limits['HS_cis/CA/rot_ang/99.99'] = {'max': 61.563761249840162, 'min': -66.185754738727965} # lost: 0
limits['HS_cis/CC/dist/100.00'] = {'max': 7.9513208589721032, 'min': 6.0268202836328086} # lost: 0
limits['HS_cis/CC/dist/95.00'] = {'max': 7.9088713847617607, 'min': 6.1688169546846012} # lost: 11
limits['HS_cis/CC/dist/99.00'] = {'max': 7.9367526983363526, 'min': 6.0795613711538703} # lost: 2
limits['HS_cis/CC/dist/99.50'] = {'max': 7.9367526983363526, 'min': 6.0268202836328086} # lost: 1
limits['HS_cis/CC/dist/99.90'] = {'max': 7.9513208589721032, 'min': 6.0268202836328086} # lost: 0
limits['HS_cis/CC/dist/99.99'] = {'max': 7.9513208589721032, 'min': 6.0268202836328086} # lost: 0
limits['HS_cis/CC/min_dist/100.00'] = {'max': 2.5438161178812462, 'min': 1.3125170461127489} # lost: 0
limits['HS_cis/CC/min_dist/95.00'] = {'max': 2.4882406804895956, 'min': 1.6077561492668189} # lost: 11
limits['HS_cis/CC/min_dist/99.00'] = {'max': 2.5108791934195787, 'min': 1.5351120381088028} # lost: 2
limits['HS_cis/CC/min_dist/99.50'] = {'max': 2.5108791934195787, 'min': 1.3125170461127489} # lost: 1
limits['HS_cis/CC/min_dist/99.90'] = {'max': 2.5438161178812462, 'min': 1.3125170461127489} # lost: 0
limits['HS_cis/CC/min_dist/99.99'] = {'max': 2.5438161178812462, 'min': 1.3125170461127489} # lost: 0
limits['HS_cis/CC/n2_z/100.00'] = {'max': 0.99615085, 'min': 0.46561107} # lost: 0
limits['HS_cis/CC/n2_z/95.00'] = {'max': 0.99615085, 'min': 0.60264105} # lost: 11
limits['HS_cis/CC/n2_z/99.00'] = {'max': 0.99615085, 'min': 0.54016513} # lost: 2
limits['HS_cis/CC/n2_z/99.50'] = {'max': 0.99615085, 'min': 0.52319098} # lost: 1
limits['HS_cis/CC/n2_z/99.90'] = {'max': 0.99615085, 'min': 0.46561107} # lost: 0
limits['HS_cis/CC/n2_z/99.99'] = {'max': 0.99615085, 'min': 0.46561107} # lost: 0
limits['HS_cis/CC/nn_ang_norm/100.00'] = {'max': 60.451620607762521, 'min': 4.0887339447299302} # lost: 0
limits['HS_cis/CC/nn_ang_norm/95.00'] = {'max': 53.381435665788452, 'min': 4.0887339447299302} # lost: 11
limits['HS_cis/CC/nn_ang_norm/99.00'] = {'max': 57.472797525801546, 'min': 4.0887339447299302} # lost: 2
limits['HS_cis/CC/nn_ang_norm/99.50'] = {'max': 58.302446943904656, 'min': 4.0887339447299302} # lost: 1
limits['HS_cis/CC/nn_ang_norm/99.90'] = {'max': 60.451620607762521, 'min': 4.0887339447299302} # lost: 0
limits['HS_cis/CC/nn_ang_norm/99.99'] = {'max': 60.451620607762521, 'min': 4.0887339447299302} # lost: 0
limits['HS_cis/CC/rot_ang/100.00'] = {'max': 68.097760343752952, 'min': -66.610379870463817} # lost: 0
limits['HS_cis/CC/rot_ang/95.00'] = {'max': 51.585298394453737, 'min': -63.494577130358238} # lost: 11
limits['HS_cis/CC/rot_ang/99.00'] = {'max': 54.610419237998464, 'min': -65.937500657361127} # lost: 2
limits['HS_cis/CC/rot_ang/99.50'] = {'max': 54.610419237998464, 'min': -66.610379870463817} # lost: 1
limits['HS_cis/CC/rot_ang/99.90'] = {'max': 68.097760343752952, 'min': -66.610379870463817} # lost: 0
limits['HS_cis/CC/rot_ang/99.99'] = {'max': 68.097760343752952, 'min': -66.610379870463817} # lost: 0
limits['HS_cis/CG/dist/100.00'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['HS_cis/CG/dist/95.00'] = {'max': 7.063937620576942, 'min': 5.6717686624084278} # lost: 2
limits['HS_cis/CG/dist/99.00'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['HS_cis/CG/dist/99.50'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['HS_cis/CG/dist/99.90'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['HS_cis/CG/dist/99.99'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['HS_cis/CG/min_dist/100.00'] = {'max': 2.6151400578263209, 'min': 0.86230812637813625} # lost: 0
limits['HS_cis/CG/min_dist/95.00'] = {'max': 2.573546150774054, 'min': 1.1796054075736531} # lost: 2
limits['HS_cis/CG/min_dist/99.00'] = {'max': 2.6151400578263209, 'min': 0.86230812637813625} # lost: 0
limits['HS_cis/CG/min_dist/99.50'] = {'max': 2.6151400578263209, 'min': 0.86230812637813625} # lost: 0
limits['HS_cis/CG/min_dist/99.90'] = {'max': 2.6151400578263209, 'min': 0.86230812637813625} # lost: 0
limits['HS_cis/CG/min_dist/99.99'] = {'max': 2.6151400578263209, 'min': 0.86230812637813625} # lost: 0
limits['HS_cis/CG/n2_z/100.00'] = {'max': 0.99990499, 'min': 0.70588052} # lost: 0
limits['HS_cis/CG/n2_z/95.00'] = {'max': 0.99990499, 'min': 0.70589513} # lost: 2
limits['HS_cis/CG/n2_z/99.00'] = {'max': 0.99990499, 'min': 0.70588052} # lost: 0
limits['HS_cis/CG/n2_z/99.50'] = {'max': 0.99990499, 'min': 0.70588052} # lost: 0
limits['HS_cis/CG/n2_z/99.90'] = {'max': 0.99990499, 'min': 0.70588052} # lost: 0
limits['HS_cis/CG/n2_z/99.99'] = {'max': 0.99990499, 'min': 0.70588052} # lost: 0
limits['HS_cis/CG/nn_ang_norm/100.00'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['HS_cis/CG/nn_ang_norm/95.00'] = {'max': 45.417096999189667, 'min': 0.58047179082402589} # lost: 2
limits['HS_cis/CG/nn_ang_norm/99.00'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['HS_cis/CG/nn_ang_norm/99.50'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['HS_cis/CG/nn_ang_norm/99.90'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['HS_cis/CG/nn_ang_norm/99.99'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['HS_cis/CG/rot_ang/100.00'] = {'max': 45.187622158585725, 'min': -48.413509419152476} # lost: 0
limits['HS_cis/CG/rot_ang/95.00'] = {'max': 45.187622158585725, 'min': -39.329397977236972} # lost: 2
limits['HS_cis/CG/rot_ang/99.00'] = {'max': 45.187622158585725, 'min': -48.413509419152476} # lost: 0
limits['HS_cis/CG/rot_ang/99.50'] = {'max': 45.187622158585725, 'min': -48.413509419152476} # lost: 0
limits['HS_cis/CG/rot_ang/99.90'] = {'max': 45.187622158585725, 'min': -48.413509419152476} # lost: 0
limits['HS_cis/CG/rot_ang/99.99'] = {'max': 45.187622158585725, 'min': -48.413509419152476} # lost: 0
limits['HS_cis/CU/dist/100.00'] = {'max': 8.1343900048538877, 'min': 6.064622536278506} # lost: 0
limits['HS_cis/CU/dist/95.00'] = {'max': 7.8773695254130658, 'min': 6.7178778908451955} # lost: 27
limits['HS_cis/CU/dist/99.00'] = {'max': 7.9700783277249743, 'min': 6.5298154136508879} # lost: 5
limits['HS_cis/CU/dist/99.50'] = {'max': 8.0602139718422219, 'min': 6.2104571241878856} # lost: 2
limits['HS_cis/CU/dist/99.90'] = {'max': 8.1343900048538877, 'min': 6.064622536278506} # lost: 0
limits['HS_cis/CU/dist/99.99'] = {'max': 8.1343900048538877, 'min': 6.064622536278506} # lost: 0
limits['HS_cis/CU/min_dist/100.00'] = {'max': 2.6816122541574918, 'min': 1.5089325509890692} # lost: 0
limits['HS_cis/CU/min_dist/95.00'] = {'max': 2.4600829364786172, 'min': 1.7027544807262895} # lost: 27
limits['HS_cis/CU/min_dist/99.00'] = {'max': 2.5449999232680702, 'min': 1.5601233599634206} # lost: 5
limits['HS_cis/CU/min_dist/99.50'] = {'max': 2.6749857614554577, 'min': 1.548594874833193} # lost: 2
limits['HS_cis/CU/min_dist/99.90'] = {'max': 2.6816122541574918, 'min': 1.5089325509890692} # lost: 0
limits['HS_cis/CU/min_dist/99.99'] = {'max': 2.6816122541574918, 'min': 1.5089325509890692} # lost: 0
limits['HS_cis/CU/n2_z/100.00'] = {'max': 0.99977386, 'min': 0.6441834} # lost: 0
limits['HS_cis/CU/n2_z/95.00'] = {'max': 0.99977386, 'min': 0.81929785} # lost: 27
limits['HS_cis/CU/n2_z/99.00'] = {'max': 0.99977386, 'min': 0.67957097} # lost: 5
limits['HS_cis/CU/n2_z/99.50'] = {'max': 0.99977386, 'min': 0.644669} # lost: 2
limits['HS_cis/CU/n2_z/99.90'] = {'max': 0.99977386, 'min': 0.6441834} # lost: 0
limits['HS_cis/CU/n2_z/99.99'] = {'max': 0.99977386, 'min': 0.6441834} # lost: 0
limits['HS_cis/CU/nn_ang_norm/100.00'] = {'max': 50.14453730113312, 'min': 0.90655019780316504} # lost: 0
limits['HS_cis/CU/nn_ang_norm/95.00'] = {'max': 36.081065101955566, 'min': 0.90655019780316504} # lost: 27
limits['HS_cis/CU/nn_ang_norm/99.00'] = {'max': 47.170389483659015, 'min': 0.90655019780316504} # lost: 5
limits['HS_cis/CU/nn_ang_norm/99.50'] = {'max': 50.067393729552414, 'min': 0.90655019780316504} # lost: 2
limits['HS_cis/CU/nn_ang_norm/99.90'] = {'max': 50.14453730113312, 'min': 0.90655019780316504} # lost: 0
limits['HS_cis/CU/nn_ang_norm/99.99'] = {'max': 50.14453730113312, 'min': 0.90655019780316504} # lost: 0
limits['HS_cis/CU/rot_ang/100.00'] = {'max': 52.153862303573881, 'min': -66.963681514582305} # lost: 0
limits['HS_cis/CU/rot_ang/95.00'] = {'max': 26.642148089150279, 'min': -56.301816924905118} # lost: 27
limits['HS_cis/CU/rot_ang/99.00'] = {'max': 38.315082344808729, 'min': -62.702900815958706} # lost: 5
limits['HS_cis/CU/rot_ang/99.50'] = {'max': 47.5322610887115, 'min': -63.937752658489849} # lost: 2
limits['HS_cis/CU/rot_ang/99.90'] = {'max': 52.153862303573881, 'min': -66.963681514582305} # lost: 0
limits['HS_cis/CU/rot_ang/99.99'] = {'max': 52.153862303573881, 'min': -66.963681514582305} # lost: 0
limits['HS_cis/GA/dist/100.00'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['HS_cis/GA/dist/95.00'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['HS_cis/GA/dist/99.00'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['HS_cis/GA/dist/99.50'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['HS_cis/GA/dist/99.90'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['HS_cis/GA/dist/99.99'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['HS_cis/GA/min_dist/100.00'] = {'max': 2.7495507032115434, 'min': 1.5408352911980299} # lost: 0
limits['HS_cis/GA/min_dist/95.00'] = {'max': 2.7495507032115434, 'min': 1.5408352911980299} # lost: 0
limits['HS_cis/GA/min_dist/99.00'] = {'max': 2.7495507032115434, 'min': 1.5408352911980299} # lost: 0
limits['HS_cis/GA/min_dist/99.50'] = {'max': 2.7495507032115434, 'min': 1.5408352911980299} # lost: 0
limits['HS_cis/GA/min_dist/99.90'] = {'max': 2.7495507032115434, 'min': 1.5408352911980299} # lost: 0
limits['HS_cis/GA/min_dist/99.99'] = {'max': 2.7495507032115434, 'min': 1.5408352911980299} # lost: 0
limits['HS_cis/GA/n2_z/100.00'] = {'max': 0.99651492, 'min': 0.97114873} # lost: 0
limits['HS_cis/GA/n2_z/95.00'] = {'max': 0.99651492, 'min': 0.97114873} # lost: 0
limits['HS_cis/GA/n2_z/99.00'] = {'max': 0.99651492, 'min': 0.97114873} # lost: 0
limits['HS_cis/GA/n2_z/99.50'] = {'max': 0.99651492, 'min': 0.97114873} # lost: 0
limits['HS_cis/GA/n2_z/99.90'] = {'max': 0.99651492, 'min': 0.97114873} # lost: 0
limits['HS_cis/GA/n2_z/99.99'] = {'max': 0.99651492, 'min': 0.97114873} # lost: 0
limits['HS_cis/GA/nn_ang_norm/100.00'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['HS_cis/GA/nn_ang_norm/95.00'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['HS_cis/GA/nn_ang_norm/99.00'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['HS_cis/GA/nn_ang_norm/99.50'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['HS_cis/GA/nn_ang_norm/99.90'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['HS_cis/GA/nn_ang_norm/99.99'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['HS_cis/GA/rot_ang/100.00'] = {'max': 9.8995261848606049, 'min': -24.106664486161677} # lost: 0
limits['HS_cis/GA/rot_ang/95.00'] = {'max': 9.8995261848606049, 'min': -24.106664486161677} # lost: 0
limits['HS_cis/GA/rot_ang/99.00'] = {'max': 9.8995261848606049, 'min': -24.106664486161677} # lost: 0
limits['HS_cis/GA/rot_ang/99.50'] = {'max': 9.8995261848606049, 'min': -24.106664486161677} # lost: 0
limits['HS_cis/GA/rot_ang/99.90'] = {'max': 9.8995261848606049, 'min': -24.106664486161677} # lost: 0
limits['HS_cis/GA/rot_ang/99.99'] = {'max': 9.8995261848606049, 'min': -24.106664486161677} # lost: 0
limits['HS_cis/GG/dist/100.00'] = {'max': 8.1059578813363764, 'min': 6.2290357474088687} # lost: 0
limits['HS_cis/GG/dist/95.00'] = {'max': 7.8840385669808422, 'min': 6.5488126856729538} # lost: 15
limits['HS_cis/GG/dist/99.00'] = {'max': 7.9610796667539905, 'min': 6.3940597710621407} # lost: 3
limits['HS_cis/GG/dist/99.50'] = {'max': 8.088890000545172, 'min': 6.2290357474088687} # lost: 1
limits['HS_cis/GG/dist/99.90'] = {'max': 8.1059578813363764, 'min': 6.2290357474088687} # lost: 0
limits['HS_cis/GG/dist/99.99'] = {'max': 8.1059578813363764, 'min': 6.2290357474088687} # lost: 0
limits['HS_cis/GG/min_dist/100.00'] = {'max': 2.5668162974587618, 'min': 1.5243344769965685} # lost: 0
limits['HS_cis/GG/min_dist/95.00'] = {'max': 2.4780646684764838, 'min': 1.696401969954362} # lost: 15
limits['HS_cis/GG/min_dist/99.00'] = {'max': 2.5423278709883834, 'min': 1.630847006162303} # lost: 3
limits['HS_cis/GG/min_dist/99.50'] = {'max': 2.548982296581964, 'min': 1.5243344769965685} # lost: 1
limits['HS_cis/GG/min_dist/99.90'] = {'max': 2.5668162974587618, 'min': 1.5243344769965685} # lost: 0
limits['HS_cis/GG/min_dist/99.99'] = {'max': 2.5668162974587618, 'min': 1.5243344769965685} # lost: 0
limits['HS_cis/GG/n2_z/100.00'] = {'max': 0.9908424, 'min': 0.44886303} # lost: 0
limits['HS_cis/GG/n2_z/95.00'] = {'max': 0.9908424, 'min': 0.63993621} # lost: 15
limits['HS_cis/GG/n2_z/99.00'] = {'max': 0.9908424, 'min': 0.51485121} # lost: 3
limits['HS_cis/GG/n2_z/99.50'] = {'max': 0.9908424, 'min': 0.49160901} # lost: 1
limits['HS_cis/GG/n2_z/99.90'] = {'max': 0.9908424, 'min': 0.44886303} # lost: 0
limits['HS_cis/GG/n2_z/99.99'] = {'max': 0.9908424, 'min': 0.44886303} # lost: 0
limits['HS_cis/GG/nn_ang_norm/100.00'] = {'max': 63.985683427732184, 'min': 7.511727643511426} # lost: 0
limits['HS_cis/GG/nn_ang_norm/95.00'] = {'max': 50.015590159792453, 'min': 7.511727643511426} # lost: 15
limits['HS_cis/GG/nn_ang_norm/99.00'] = {'max': 59.293507392473501, 'min': 7.511727643511426} # lost: 3
limits['HS_cis/GG/nn_ang_norm/99.50'] = {'max': 60.59818963716183, 'min': 7.511727643511426} # lost: 1
limits['HS_cis/GG/nn_ang_norm/99.90'] = {'max': 63.985683427732184, 'min': 7.511727643511426} # lost: 0
limits['HS_cis/GG/nn_ang_norm/99.99'] = {'max': 63.985683427732184, 'min': 7.511727643511426} # lost: 0
limits['HS_cis/GG/rot_ang/100.00'] = {'max': 79.852956904005779, 'min': -58.037356178428325} # lost: 0
limits['HS_cis/GG/rot_ang/95.00'] = {'max': 59.739440747609784, 'min': -53.531204887272487} # lost: 15
limits['HS_cis/GG/rot_ang/99.00'] = {'max': 69.757034184863286, 'min': -57.571247195797646} # lost: 3
limits['HS_cis/GG/rot_ang/99.50'] = {'max': 69.760681245241557, 'min': -58.037356178428325} # lost: 1
limits['HS_cis/GG/rot_ang/99.90'] = {'max': 79.852956904005779, 'min': -58.037356178428325} # lost: 0
limits['HS_cis/GG/rot_ang/99.99'] = {'max': 79.852956904005779, 'min': -58.037356178428325} # lost: 0
limits['HS_cis/UA/dist/100.00'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['HS_cis/UA/dist/95.00'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['HS_cis/UA/dist/99.00'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['HS_cis/UA/dist/99.50'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['HS_cis/UA/dist/99.90'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['HS_cis/UA/dist/99.99'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['HS_cis/UA/min_dist/100.00'] = {'max': 2.6047465884940224, 'min': 1.3489661591153761} # lost: 0
limits['HS_cis/UA/min_dist/95.00'] = {'max': 2.6047465884940224, 'min': 1.3489661591153761} # lost: 0
limits['HS_cis/UA/min_dist/99.00'] = {'max': 2.6047465884940224, 'min': 1.3489661591153761} # lost: 0
limits['HS_cis/UA/min_dist/99.50'] = {'max': 2.6047465884940224, 'min': 1.3489661591153761} # lost: 0
limits['HS_cis/UA/min_dist/99.90'] = {'max': 2.6047465884940224, 'min': 1.3489661591153761} # lost: 0
limits['HS_cis/UA/min_dist/99.99'] = {'max': 2.6047465884940224, 'min': 1.3489661591153761} # lost: 0
limits['HS_cis/UA/n2_z/100.00'] = {'max': 0.99715585, 'min': 0.88514799} # lost: 0
limits['HS_cis/UA/n2_z/95.00'] = {'max': 0.99715585, 'min': 0.88514799} # lost: 0
limits['HS_cis/UA/n2_z/99.00'] = {'max': 0.99715585, 'min': 0.88514799} # lost: 0
limits['HS_cis/UA/n2_z/99.50'] = {'max': 0.99715585, 'min': 0.88514799} # lost: 0
limits['HS_cis/UA/n2_z/99.90'] = {'max': 0.99715585, 'min': 0.88514799} # lost: 0
limits['HS_cis/UA/n2_z/99.99'] = {'max': 0.99715585, 'min': 0.88514799} # lost: 0
limits['HS_cis/UA/nn_ang_norm/100.00'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['HS_cis/UA/nn_ang_norm/95.00'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['HS_cis/UA/nn_ang_norm/99.00'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['HS_cis/UA/nn_ang_norm/99.50'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['HS_cis/UA/nn_ang_norm/99.90'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['HS_cis/UA/nn_ang_norm/99.99'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['HS_cis/UA/rot_ang/100.00'] = {'max': 11.330224940467776, 'min': -28.075447541112879} # lost: 0
limits['HS_cis/UA/rot_ang/95.00'] = {'max': 11.330224940467776, 'min': -28.075447541112879} # lost: 0
limits['HS_cis/UA/rot_ang/99.00'] = {'max': 11.330224940467776, 'min': -28.075447541112879} # lost: 0
limits['HS_cis/UA/rot_ang/99.50'] = {'max': 11.330224940467776, 'min': -28.075447541112879} # lost: 0
limits['HS_cis/UA/rot_ang/99.90'] = {'max': 11.330224940467776, 'min': -28.075447541112879} # lost: 0
limits['HS_cis/UA/rot_ang/99.99'] = {'max': 11.330224940467776, 'min': -28.075447541112879} # lost: 0
limits['HS_cis/UC/dist/100.00'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['HS_cis/UC/dist/95.00'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['HS_cis/UC/dist/99.00'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['HS_cis/UC/dist/99.50'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['HS_cis/UC/dist/99.90'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['HS_cis/UC/dist/99.99'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['HS_cis/UC/min_dist/100.00'] = {'max': 2.447604758569196, 'min': 2.1599291718859783} # lost: 0
limits['HS_cis/UC/min_dist/95.00'] = {'max': 2.447604758569196, 'min': 2.1599291718859783} # lost: 0
limits['HS_cis/UC/min_dist/99.00'] = {'max': 2.447604758569196, 'min': 2.1599291718859783} # lost: 0
limits['HS_cis/UC/min_dist/99.50'] = {'max': 2.447604758569196, 'min': 2.1599291718859783} # lost: 0
limits['HS_cis/UC/min_dist/99.90'] = {'max': 2.447604758569196, 'min': 2.1599291718859783} # lost: 0
limits['HS_cis/UC/min_dist/99.99'] = {'max': 2.447604758569196, 'min': 2.1599291718859783} # lost: 0
limits['HS_cis/UC/n2_z/100.00'] = {'max': 0.968077, 'min': 0.87743664} # lost: 0
limits['HS_cis/UC/n2_z/95.00'] = {'max': 0.968077, 'min': 0.87743664} # lost: 0
limits['HS_cis/UC/n2_z/99.00'] = {'max': 0.968077, 'min': 0.87743664} # lost: 0
limits['HS_cis/UC/n2_z/99.50'] = {'max': 0.968077, 'min': 0.87743664} # lost: 0
limits['HS_cis/UC/n2_z/99.90'] = {'max': 0.968077, 'min': 0.87743664} # lost: 0
limits['HS_cis/UC/n2_z/99.99'] = {'max': 0.968077, 'min': 0.87743664} # lost: 0
limits['HS_cis/UC/nn_ang_norm/100.00'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['HS_cis/UC/nn_ang_norm/95.00'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['HS_cis/UC/nn_ang_norm/99.00'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['HS_cis/UC/nn_ang_norm/99.50'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['HS_cis/UC/nn_ang_norm/99.90'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['HS_cis/UC/nn_ang_norm/99.99'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['HS_cis/UC/rot_ang/100.00'] = {'max': 29.693367976884055, 'min': 23.271058712123022} # lost: 0
limits['HS_cis/UC/rot_ang/95.00'] = {'max': 29.693367976884055, 'min': 23.271058712123022} # lost: 0
limits['HS_cis/UC/rot_ang/99.00'] = {'max': 29.693367976884055, 'min': 23.271058712123022} # lost: 0
limits['HS_cis/UC/rot_ang/99.50'] = {'max': 29.693367976884055, 'min': 23.271058712123022} # lost: 0
limits['HS_cis/UC/rot_ang/99.90'] = {'max': 29.693367976884055, 'min': 23.271058712123022} # lost: 0
limits['HS_cis/UC/rot_ang/99.99'] = {'max': 29.693367976884055, 'min': 23.271058712123022} # lost: 0
limits['HS_cis/UG/dist/100.00'] = {'max': 7.9376564435433812, 'min': 5.5260246994208986} # lost: 0
limits['HS_cis/UG/dist/95.00'] = {'max': 7.4011515254815166, 'min': 5.9684496567097547} # lost: 168
limits['HS_cis/UG/dist/99.00'] = {'max': 7.7161663681277899, 'min': 5.774782601048793} # lost: 33
limits['HS_cis/UG/dist/99.50'] = {'max': 7.7663052653450686, 'min': 5.7256345901036658} # lost: 16
limits['HS_cis/UG/dist/99.90'] = {'max': 7.8693351701554572, 'min': 5.5491606577307993} # lost: 3
limits['HS_cis/UG/dist/99.99'] = {'max': 7.9376564435433812, 'min': 5.5260246994208986} # lost: 0
limits['HS_cis/UG/min_dist/100.00'] = {'max': 3.1272913465130179, 'min': 0.97262692723533173} # lost: 0
limits['HS_cis/UG/min_dist/95.00'] = {'max': 2.487165465985735, 'min': 1.5476843993337195} # lost: 168
limits['HS_cis/UG/min_dist/99.00'] = {'max': 2.7883951444278243, 'min': 1.3976918202990412} # lost: 33
limits['HS_cis/UG/min_dist/99.50'] = {'max': 2.9687103094407132, 'min': 1.3304885500422718} # lost: 16
limits['HS_cis/UG/min_dist/99.90'] = {'max': 3.1244896560452493, 'min': 1.1565406547514931} # lost: 3
limits['HS_cis/UG/min_dist/99.99'] = {'max': 3.1272913465130179, 'min': 0.97262692723533173} # lost: 0
limits['HS_cis/UG/n2_z/100.00'] = {'max': 0.99999565, 'min': 0.44923404} # lost: 0
limits['HS_cis/UG/n2_z/95.00'] = {'max': 0.99999565, 'min': 0.76211655} # lost: 168
limits['HS_cis/UG/n2_z/99.00'] = {'max': 0.99999565, 'min': 0.63509822} # lost: 33
limits['HS_cis/UG/n2_z/99.50'] = {'max': 0.99999565, 'min': 0.5401386} # lost: 16
limits['HS_cis/UG/n2_z/99.90'] = {'max': 0.99999565, 'min': 0.468104} # lost: 3
limits['HS_cis/UG/n2_z/99.99'] = {'max': 0.99999565, 'min': 0.44923404} # lost: 0
limits['HS_cis/UG/nn_ang_norm/100.00'] = {'max': 64.357348171418423, 'min': 0.17804114037233401} # lost: 0
limits['HS_cis/UG/nn_ang_norm/95.00'] = {'max': 40.268380874523579, 'min': 0.17804114037233401} # lost: 168
limits['HS_cis/UG/nn_ang_norm/99.00'] = {'max': 50.813284537863659, 'min': 0.17804114037233401} # lost: 33
limits['HS_cis/UG/nn_ang_norm/99.50'] = {'max': 56.980620924399595, 'min': 0.17804114037233401} # lost: 16
limits['HS_cis/UG/nn_ang_norm/99.90'] = {'max': 62.760695830279566, 'min': 0.17804114037233401} # lost: 3
limits['HS_cis/UG/nn_ang_norm/99.99'] = {'max': 64.357348171418423, 'min': 0.17804114037233401} # lost: 0
limits['HS_cis/UG/rot_ang/100.00'] = {'max': 83.73640212094142, 'min': -53.235990046277969} # lost: 0
limits['HS_cis/UG/rot_ang/95.00'] = {'max': 47.882194175549955, 'min': -31.621079935426994} # lost: 168
limits['HS_cis/UG/rot_ang/99.00'] = {'max': 63.495341356712608, 'min': -38.853626383033451} # lost: 33
limits['HS_cis/UG/rot_ang/99.50'] = {'max': 69.204515296161489, 'min': -43.920322527393459} # lost: 16
limits['HS_cis/UG/rot_ang/99.90'] = {'max': 82.464695929544533, 'min': -49.506998494172741} # lost: 3
limits['HS_cis/UG/rot_ang/99.99'] = {'max': 83.73640212094142, 'min': -53.235990046277969} # lost: 0
limits['HS_cis/UU/dist/100.00'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['HS_cis/UU/dist/95.00'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['HS_cis/UU/dist/99.00'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['HS_cis/UU/dist/99.50'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['HS_cis/UU/dist/99.90'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['HS_cis/UU/dist/99.99'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['HS_cis/UU/min_dist/100.00'] = {'max': 2.5609962641729891, 'min': 2.0973586623046132} # lost: 0
limits['HS_cis/UU/min_dist/95.00'] = {'max': 2.5609962641729891, 'min': 2.0973586623046132} # lost: 0
limits['HS_cis/UU/min_dist/99.00'] = {'max': 2.5609962641729891, 'min': 2.0973586623046132} # lost: 0
limits['HS_cis/UU/min_dist/99.50'] = {'max': 2.5609962641729891, 'min': 2.0973586623046132} # lost: 0
limits['HS_cis/UU/min_dist/99.90'] = {'max': 2.5609962641729891, 'min': 2.0973586623046132} # lost: 0
limits['HS_cis/UU/min_dist/99.99'] = {'max': 2.5609962641729891, 'min': 2.0973586623046132} # lost: 0
limits['HS_cis/UU/n2_z/100.00'] = {'max': 0.96905851, 'min': 0.86458808} # lost: 0
limits['HS_cis/UU/n2_z/95.00'] = {'max': 0.96905851, 'min': 0.86458808} # lost: 0
limits['HS_cis/UU/n2_z/99.00'] = {'max': 0.96905851, 'min': 0.86458808} # lost: 0
limits['HS_cis/UU/n2_z/99.50'] = {'max': 0.96905851, 'min': 0.86458808} # lost: 0
limits['HS_cis/UU/n2_z/99.90'] = {'max': 0.96905851, 'min': 0.86458808} # lost: 0
limits['HS_cis/UU/n2_z/99.99'] = {'max': 0.96905851, 'min': 0.86458808} # lost: 0
limits['HS_cis/UU/nn_ang_norm/100.00'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['HS_cis/UU/nn_ang_norm/95.00'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['HS_cis/UU/nn_ang_norm/99.00'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['HS_cis/UU/nn_ang_norm/99.50'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['HS_cis/UU/nn_ang_norm/99.90'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['HS_cis/UU/nn_ang_norm/99.99'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['HS_cis/UU/rot_ang/100.00'] = {'max': 30.460862012986375, 'min': -30.548971021250345} # lost: 0
limits['HS_cis/UU/rot_ang/95.00'] = {'max': 30.460862012986375, 'min': -30.548971021250345} # lost: 0
limits['HS_cis/UU/rot_ang/99.00'] = {'max': 30.460862012986375, 'min': -30.548971021250345} # lost: 0
limits['HS_cis/UU/rot_ang/99.50'] = {'max': 30.460862012986375, 'min': -30.548971021250345} # lost: 0
limits['HS_cis/UU/rot_ang/99.90'] = {'max': 30.460862012986375, 'min': -30.548971021250345} # lost: 0
limits['HS_cis/UU/rot_ang/99.99'] = {'max': 30.460862012986375, 'min': -30.548971021250345} # lost: 0
limits['HS_tran/AA/dist/100.00'] = {'max': 7.1671028525189611, 'min': 5.0927797039838101} # lost: 0
limits['HS_tran/AA/dist/95.00'] = {'max': 6.9145920709158748, 'min': 5.9885366721996487} # lost: 98
limits['HS_tran/AA/dist/99.00'] = {'max': 7.0441263279077919, 'min': 5.5806501289880499} # lost: 19
limits['HS_tran/AA/dist/99.50'] = {'max': 7.0592431477028761, 'min': 5.5762623245702043} # lost: 9
limits['HS_tran/AA/dist/99.90'] = {'max': 7.1575633646428454, 'min': 5.0927797039838101} # lost: 1
limits['HS_tran/AA/dist/99.99'] = {'max': 7.1671028525189611, 'min': 5.0927797039838101} # lost: 0
limits['HS_tran/AA/min_dist/100.00'] = {'max': 2.6367583970698352, 'min': 1.0821209853014861} # lost: 0
limits['HS_tran/AA/min_dist/95.00'] = {'max': 2.4289811581879088, 'min': 1.6779077155279547} # lost: 98
limits['HS_tran/AA/min_dist/99.00'] = {'max': 2.5225227115200193, 'min': 1.5046682580985038} # lost: 19
limits['HS_tran/AA/min_dist/99.50'] = {'max': 2.5561631851018549, 'min': 1.4356767406455657} # lost: 9
limits['HS_tran/AA/min_dist/99.90'] = {'max': 2.6172415103432956, 'min': 1.0821209853014861} # lost: 1
limits['HS_tran/AA/min_dist/99.99'] = {'max': 2.6367583970698352, 'min': 1.0821209853014861} # lost: 0
limits['HS_tran/AA/n2_z/100.00'] = {'max': -0.42353746, 'min': -0.99998844} # lost: 0
limits['HS_tran/AA/n2_z/95.00'] = {'max': -0.8192333, 'min': -0.99998844} # lost: 98
limits['HS_tran/AA/n2_z/99.00'] = {'max': -0.66520482, 'min': -0.99998844} # lost: 19
limits['HS_tran/AA/n2_z/99.50'] = {'max': -0.50129378, 'min': -0.99998844} # lost: 9
limits['HS_tran/AA/n2_z/99.90'] = {'max': -0.4477571, 'min': -0.99998844} # lost: 1
limits['HS_tran/AA/n2_z/99.99'] = {'max': -0.42353746, 'min': -0.99998844} # lost: 0
limits['HS_tran/AA/nn_ang_norm/100.00'] = {'max': 64.644293069872674, 'min': 0.30646557910213801} # lost: 0
limits['HS_tran/AA/nn_ang_norm/95.00'] = {'max': 34.793839226924035, 'min': 0.30646557910213801} # lost: 98
limits['HS_tran/AA/nn_ang_norm/99.00'] = {'max': 46.549687618783196, 'min': 0.30646557910213801} # lost: 19
limits['HS_tran/AA/nn_ang_norm/99.50'] = {'max': 60.416119105689631, 'min': 0.30646557910213801} # lost: 9
limits['HS_tran/AA/nn_ang_norm/99.90'] = {'max': 62.973861025319323, 'min': 0.30646557910213801} # lost: 1
limits['HS_tran/AA/nn_ang_norm/99.99'] = {'max': 64.644293069872674, 'min': 0.30646557910213801} # lost: 0
limits['HS_tran/AA/rot_ang/100.00'] = {'max': 129.16743006334653, 'min': 58.052005626034969} # lost: 0
limits['HS_tran/AA/rot_ang/95.00'] = {'max': 104.27278543416577, 'min': 70.055964632869305} # lost: 98
limits['HS_tran/AA/rot_ang/99.00'] = {'max': 115.52407563664669, 'min': 66.444754628122539} # lost: 19
limits['HS_tran/AA/rot_ang/99.50'] = {'max': 116.81109915104528, 'min': 65.561572293033166} # lost: 9
limits['HS_tran/AA/rot_ang/99.90'] = {'max': 125.90281597509717, 'min': 58.052005626034969} # lost: 1
limits['HS_tran/AA/rot_ang/99.99'] = {'max': 129.16743006334653, 'min': 58.052005626034969} # lost: 0
limits['HS_tran/AC/dist/100.00'] = {'max': 8.2554230507350219, 'min': 6.7296936773893785} # lost: 0
limits['HS_tran/AC/dist/95.00'] = {'max': 8.1212033051294696, 'min': 7.0657401192186553} # lost: 23
limits['HS_tran/AC/dist/99.00'] = {'max': 8.1946639258618266, 'min': 6.8290733310488196} # lost: 4
limits['HS_tran/AC/dist/99.50'] = {'max': 8.1992888908513386, 'min': 6.7691149430985025} # lost: 2
limits['HS_tran/AC/dist/99.90'] = {'max': 8.2554230507350219, 'min': 6.7296936773893785} # lost: 0
limits['HS_tran/AC/dist/99.99'] = {'max': 8.2554230507350219, 'min': 6.7296936773893785} # lost: 0
limits['HS_tran/AC/min_dist/100.00'] = {'max': 2.4488243667631848, 'min': 0.81494936433133025} # lost: 0
limits['HS_tran/AC/min_dist/95.00'] = {'max': 2.3874540779409079, 'min': 1.4471034314690072} # lost: 23
limits['HS_tran/AC/min_dist/99.00'] = {'max': 2.4388056521720638, 'min': 1.2486941049361751} # lost: 4
limits['HS_tran/AC/min_dist/99.50'] = {'max': 2.4432699807399998, 'min': 1.1468327075056717} # lost: 2
limits['HS_tran/AC/min_dist/99.90'] = {'max': 2.4488243667631848, 'min': 0.81494936433133025} # lost: 0
limits['HS_tran/AC/min_dist/99.99'] = {'max': 2.4488243667631848, 'min': 0.81494936433133025} # lost: 0
limits['HS_tran/AC/n2_z/100.00'] = {'max': -0.61956161, 'min': -0.99949104} # lost: 0
limits['HS_tran/AC/n2_z/95.00'] = {'max': -0.83339083, 'min': -0.99949104} # lost: 23
limits['HS_tran/AC/n2_z/99.00'] = {'max': -0.62018818, 'min': -0.99949104} # lost: 4
limits['HS_tran/AC/n2_z/99.50'] = {'max': -0.61987007, 'min': -0.99949104} # lost: 2
limits['HS_tran/AC/n2_z/99.90'] = {'max': -0.61956161, 'min': -0.99949104} # lost: 0
limits['HS_tran/AC/n2_z/99.99'] = {'max': -0.61956161, 'min': -0.99949104} # lost: 0
limits['HS_tran/AC/nn_ang_norm/100.00'] = {'max': 52.070324619229396, 'min': 0.71381806120169244} # lost: 0
limits['HS_tran/AC/nn_ang_norm/95.00'] = {'max': 34.103361743349126, 'min': 0.71381806120169244} # lost: 23
limits['HS_tran/AC/nn_ang_norm/99.00'] = {'max': 51.963473139853704, 'min': 0.71381806120169244} # lost: 4
limits['HS_tran/AC/nn_ang_norm/99.50'] = {'max': 52.040831862393276, 'min': 0.71381806120169244} # lost: 2
limits['HS_tran/AC/nn_ang_norm/99.90'] = {'max': 52.070324619229396, 'min': 0.71381806120169244} # lost: 0
limits['HS_tran/AC/nn_ang_norm/99.99'] = {'max': 52.070324619229396, 'min': 0.71381806120169244} # lost: 0
limits['HS_tran/AC/rot_ang/100.00'] = {'max': 126.27785125129137, 'min': 66.172985588877609} # lost: 0
limits['HS_tran/AC/rot_ang/95.00'] = {'max': 106.79333461857797, 'min': 74.206592063654938} # lost: 23
limits['HS_tran/AC/rot_ang/99.00'] = {'max': 118.78450166679744, 'min': 71.59060149916796} # lost: 4
limits['HS_tran/AC/rot_ang/99.50'] = {'max': 126.07140013964012, 'min': 70.947238413638871} # lost: 2
limits['HS_tran/AC/rot_ang/99.90'] = {'max': 126.27785125129137, 'min': 66.172985588877609} # lost: 0
limits['HS_tran/AC/rot_ang/99.99'] = {'max': 126.27785125129137, 'min': 66.172985588877609} # lost: 0
limits['HS_tran/AG/dist/100.00'] = {'max': 7.9993818993440335, 'min': 5.7386259561977395} # lost: 0
limits['HS_tran/AG/dist/95.00'] = {'max': 7.4540077116190391, 'min': 6.3821109694574023} # lost: 1382
limits['HS_tran/AG/dist/99.00'] = {'max': 7.6768173181530308, 'min': 6.1940544749712574} # lost: 276
limits['HS_tran/AG/dist/99.50'] = {'max': 7.7496334726172638, 'min': 6.1183513129160421} # lost: 138
limits['HS_tran/AG/dist/99.90'] = {'max': 7.8569083375242341, 'min': 5.9644625260513173} # lost: 27
limits['HS_tran/AG/dist/99.99'] = {'max': 7.9821662050474478, 'min': 5.8201211122567535} # lost: 2
limits['HS_tran/AG/min_dist/100.00'] = {'max': 3.08380604210641, 'min': 0.59679574841208727} # lost: 0
limits['HS_tran/AG/min_dist/95.00'] = {'max': 2.4499898066000472, 'min': 1.5565577285218779} # lost: 1382
limits['HS_tran/AG/min_dist/99.00'] = {'max': 2.5982283596448652, 'min': 1.2761780064189747} # lost: 276
limits['HS_tran/AG/min_dist/99.50'] = {'max': 2.6660855061928639, 'min': 1.1297646447701004} # lost: 138
limits['HS_tran/AG/min_dist/99.90'] = {'max': 2.8055669576647473, 'min': 0.83760434792451821} # lost: 27
limits['HS_tran/AG/min_dist/99.99'] = {'max': 3.041930335392105, 'min': 0.66669034365377844} # lost: 2
limits['HS_tran/AG/n2_z/100.00'] = {'max': -0.41874096, 'min': -1.0} # lost: 0
limits['HS_tran/AG/n2_z/95.00'] = {'max': -0.76135945, 'min': -1.0} # lost: 1382
limits['HS_tran/AG/n2_z/99.00'] = {'max': -0.62581819, 'min': -1.0} # lost: 276
limits['HS_tran/AG/n2_z/99.50'] = {'max': -0.58516836, 'min': -1.0} # lost: 138
limits['HS_tran/AG/n2_z/99.90'] = {'max': -0.47813538, 'min': -1.0} # lost: 27
limits['HS_tran/AG/n2_z/99.99'] = {'max': -0.42876449, 'min': -1.0} # lost: 2
limits['HS_tran/AG/nn_ang_norm/100.00'] = {'max': 64.713387263516523, 'min': 0.0} # lost: 0
limits['HS_tran/AG/nn_ang_norm/95.00'] = {'max': 40.548273602659776, 'min': 0.0} # lost: 1382
limits['HS_tran/AG/nn_ang_norm/99.00'] = {'max': 51.659475080274774, 'min': 0.0} # lost: 276
limits['HS_tran/AG/nn_ang_norm/99.50'] = {'max': 54.412164259194981, 'min': 0.0} # lost: 138
limits['HS_tran/AG/nn_ang_norm/99.90'] = {'max': 61.773578222094642, 'min': 0.0} # lost: 27
limits['HS_tran/AG/nn_ang_norm/99.99'] = {'max': 64.582657442802471, 'min': 0.0} # lost: 2
limits['HS_tran/AG/rot_ang/100.00'] = {'max': 133.92411287488474, 'min': 44.463742261038476} # lost: 0
limits['HS_tran/AG/rot_ang/95.00'] = {'max': 95.421527075651554, 'min': 63.21935034972784} # lost: 1382
limits['HS_tran/AG/rot_ang/99.00'] = {'max': 106.37475313709989, 'min': 57.658891977984503} # lost: 276
limits['HS_tran/AG/rot_ang/99.50'] = {'max': 109.92792295229519, 'min': 56.006216995748154} # lost: 138
limits['HS_tran/AG/rot_ang/99.90'] = {'max': 116.01901494627364, 'min': 51.434533324033517} # lost: 27
limits['HS_tran/AG/rot_ang/99.99'] = {'max': 132.94117554693284, 'min': 45.524876542170084} # lost: 2
limits['HS_tran/AU/dist/100.00'] = {'max': 8.2750347582988919, 'min': 6.0050976822565971} # lost: 0
limits['HS_tran/AU/dist/95.00'] = {'max': 8.0576085469828467, 'min': 6.7337653935693362} # lost: 13
limits['HS_tran/AU/dist/99.00'] = {'max': 8.2710457162776354, 'min': 6.2706303488833797} # lost: 2
limits['HS_tran/AU/dist/99.50'] = {'max': 8.2710457162776354, 'min': 6.0050976822565971} # lost: 1
limits['HS_tran/AU/dist/99.90'] = {'max': 8.2750347582988919, 'min': 6.0050976822565971} # lost: 0
limits['HS_tran/AU/dist/99.99'] = {'max': 8.2750347582988919, 'min': 6.0050976822565971} # lost: 0
limits['HS_tran/AU/min_dist/100.00'] = {'max': 2.5359372175059738, 'min': 1.1618964529540026} # lost: 0
limits['HS_tran/AU/min_dist/95.00'] = {'max': 2.3515841404001754, 'min': 1.436432445685023} # lost: 13
limits['HS_tran/AU/min_dist/99.00'] = {'max': 2.4755793676604618, 'min': 1.277607188983914} # lost: 2
limits['HS_tran/AU/min_dist/99.50'] = {'max': 2.4755793676604618, 'min': 1.1618964529540026} # lost: 1
limits['HS_tran/AU/min_dist/99.90'] = {'max': 2.5359372175059738, 'min': 1.1618964529540026} # lost: 0
limits['HS_tran/AU/min_dist/99.99'] = {'max': 2.5359372175059738, 'min': 1.1618964529540026} # lost: 0
limits['HS_tran/AU/n2_z/100.00'] = {'max': -0.64080971, 'min': -0.99937952} # lost: 0
limits['HS_tran/AU/n2_z/95.00'] = {'max': -0.76041472, 'min': -0.99937952} # lost: 13
limits['HS_tran/AU/n2_z/99.00'] = {'max': -0.68684137, 'min': -0.99937952} # lost: 2
limits['HS_tran/AU/n2_z/99.50'] = {'max': -0.66000384, 'min': -0.99937952} # lost: 1
limits['HS_tran/AU/n2_z/99.90'] = {'max': -0.64080971, 'min': -0.99937952} # lost: 0
limits['HS_tran/AU/n2_z/99.99'] = {'max': -0.64080971, 'min': -0.99937952} # lost: 0
limits['HS_tran/AU/nn_ang_norm/100.00'] = {'max': 50.180274672103479, 'min': 2.5067153975733731} # lost: 0
limits['HS_tran/AU/nn_ang_norm/95.00'] = {'max': 39.388124990998108, 'min': 2.5067153975733731} # lost: 13
limits['HS_tran/AU/nn_ang_norm/99.00'] = {'max': 44.316202099810681, 'min': 2.5067153975733731} # lost: 2
limits['HS_tran/AU/nn_ang_norm/99.50'] = {'max': 48.891295032317004, 'min': 2.5067153975733731} # lost: 1
limits['HS_tran/AU/nn_ang_norm/99.90'] = {'max': 50.180274672103479, 'min': 2.5067153975733731} # lost: 0
limits['HS_tran/AU/nn_ang_norm/99.99'] = {'max': 50.180274672103479, 'min': 2.5067153975733731} # lost: 0
limits['HS_tran/AU/rot_ang/100.00'] = {'max': 136.37457249646712, 'min': 57.304726983707916} # lost: 0
limits['HS_tran/AU/rot_ang/95.00'] = {'max': 116.97115746871478, 'min': 60.275738681213198} # lost: 13
limits['HS_tran/AU/rot_ang/99.00'] = {'max': 126.91129422285537, 'min': 58.809061601884764} # lost: 2
limits['HS_tran/AU/rot_ang/99.50'] = {'max': 126.91129422285537, 'min': 57.304726983707916} # lost: 1
limits['HS_tran/AU/rot_ang/99.90'] = {'max': 136.37457249646712, 'min': 57.304726983707916} # lost: 0
limits['HS_tran/AU/rot_ang/99.99'] = {'max': 136.37457249646712, 'min': 57.304726983707916} # lost: 0
limits['HS_tran/CA/dist/100.00'] = {'max': 7.0860374240275323, 'min': 5.3903740498326433} # lost: 0
limits['HS_tran/CA/dist/95.00'] = {'max': 6.8379551695960803, 'min': 5.7628109417665865} # lost: 18
limits['HS_tran/CA/dist/99.00'] = {'max': 6.9302750870643823, 'min': 5.7107372454699199} # lost: 3
limits['HS_tran/CA/dist/99.50'] = {'max': 7.007251928428575, 'min': 5.3903740498326433} # lost: 1
limits['HS_tran/CA/dist/99.90'] = {'max': 7.0860374240275323, 'min': 5.3903740498326433} # lost: 0
limits['HS_tran/CA/dist/99.99'] = {'max': 7.0860374240275323, 'min': 5.3903740498326433} # lost: 0
limits['HS_tran/CA/min_dist/100.00'] = {'max': 2.6813660421145555, 'min': 1.3317343723549544} # lost: 0
limits['HS_tran/CA/min_dist/95.00'] = {'max': 2.3578115641544697, 'min': 1.5452280488958621} # lost: 18
limits['HS_tran/CA/min_dist/99.00'] = {'max': 2.4760791107416664, 'min': 1.3746322836922626} # lost: 3
limits['HS_tran/CA/min_dist/99.50'] = {'max': 2.4948028894752783, 'min': 1.3317343723549544} # lost: 1
limits['HS_tran/CA/min_dist/99.90'] = {'max': 2.6813660421145555, 'min': 1.3317343723549544} # lost: 0
limits['HS_tran/CA/min_dist/99.99'] = {'max': 2.6813660421145555, 'min': 1.3317343723549544} # lost: 0
limits['HS_tran/CA/n2_z/100.00'] = {'max': -0.50197488, 'min': -0.99942392} # lost: 0
limits['HS_tran/CA/n2_z/95.00'] = {'max': -0.80532283, 'min': -0.99942392} # lost: 18
limits['HS_tran/CA/n2_z/99.00'] = {'max': -0.60777819, 'min': -0.99942392} # lost: 3
limits['HS_tran/CA/n2_z/99.50'] = {'max': -0.59582639, 'min': -0.99942392} # lost: 1
limits['HS_tran/CA/n2_z/99.90'] = {'max': -0.50197488, 'min': -0.99942392} # lost: 0
limits['HS_tran/CA/n2_z/99.99'] = {'max': -0.50197488, 'min': -0.99942392} # lost: 0
limits['HS_tran/CA/nn_ang_norm/100.00'] = {'max': 63.845939578546563, 'min': 1.8220982163063013} # lost: 0
limits['HS_tran/CA/nn_ang_norm/95.00'] = {'max': 36.022439994447609, 'min': 1.8220982163063013} # lost: 18
limits['HS_tran/CA/nn_ang_norm/99.00'] = {'max': 52.366194753696007, 'min': 1.8220982163063013} # lost: 3
limits['HS_tran/CA/nn_ang_norm/99.50'] = {'max': 56.815202394123887, 'min': 1.8220982163063013} # lost: 1
limits['HS_tran/CA/nn_ang_norm/99.90'] = {'max': 63.845939578546563, 'min': 1.8220982163063013} # lost: 0
limits['HS_tran/CA/nn_ang_norm/99.99'] = {'max': 63.845939578546563, 'min': 1.8220982163063013} # lost: 0
limits['HS_tran/CA/rot_ang/100.00'] = {'max': 124.91493373583866, 'min': 53.437516836942706} # lost: 0
limits['HS_tran/CA/rot_ang/95.00'] = {'max': 97.376584030427679, 'min': 55.560685799665059} # lost: 18
limits['HS_tran/CA/rot_ang/99.00'] = {'max': 103.40425605680193, 'min': 53.865301504813033} # lost: 3
limits['HS_tran/CA/rot_ang/99.50'] = {'max': 104.09440575337749, 'min': 53.437516836942706} # lost: 1
limits['HS_tran/CA/rot_ang/99.90'] = {'max': 124.91493373583866, 'min': 53.437516836942706} # lost: 0
limits['HS_tran/CA/rot_ang/99.99'] = {'max': 124.91493373583866, 'min': 53.437516836942706} # lost: 0
limits['HS_tran/CC/dist/100.00'] = {'max': 7.8000180232569649, 'min': 6.4662881728779986} # lost: 0
limits['HS_tran/CC/dist/95.00'] = {'max': 7.535213800717564, 'min': 6.7069092818332896} # lost: 20
limits['HS_tran/CC/dist/99.00'] = {'max': 7.6733537101119502, 'min': 6.5011642213960474} # lost: 4
limits['HS_tran/CC/dist/99.50'] = {'max': 7.7299508504012922, 'min': 6.4985434761815082} # lost: 2
limits['HS_tran/CC/dist/99.90'] = {'max': 7.8000180232569649, 'min': 6.4662881728779986} # lost: 0
limits['HS_tran/CC/dist/99.99'] = {'max': 7.8000180232569649, 'min': 6.4662881728779986} # lost: 0
limits['HS_tran/CC/min_dist/100.00'] = {'max': 2.3805866199526928, 'min': 1.2975847702118595} # lost: 0
limits['HS_tran/CC/min_dist/95.00'] = {'max': 2.2651574613853369, 'min': 1.4251435975415907} # lost: 20
limits['HS_tran/CC/min_dist/99.00'] = {'max': 2.3687278248911707, 'min': 1.3226040991836654} # lost: 4
limits['HS_tran/CC/min_dist/99.50'] = {'max': 2.3752488344002693, 'min': 1.3220958837658809} # lost: 2
limits['HS_tran/CC/min_dist/99.90'] = {'max': 2.3805866199526928, 'min': 1.2975847702118595} # lost: 0
limits['HS_tran/CC/min_dist/99.99'] = {'max': 2.3805866199526928, 'min': 1.2975847702118595} # lost: 0
limits['HS_tran/CC/n2_z/100.00'] = {'max': -0.453587, 'min': -0.99692291} # lost: 0
limits['HS_tran/CC/n2_z/95.00'] = {'max': -0.76924288, 'min': -0.99692291} # lost: 20
limits['HS_tran/CC/n2_z/99.00'] = {'max': -0.73030907, 'min': -0.99692291} # lost: 4
limits['HS_tran/CC/n2_z/99.50'] = {'max': -0.66636235, 'min': -0.99692291} # lost: 2
limits['HS_tran/CC/n2_z/99.90'] = {'max': -0.453587, 'min': -0.99692291} # lost: 0
limits['HS_tran/CC/n2_z/99.99'] = {'max': -0.453587, 'min': -0.99692291} # lost: 0
limits['HS_tran/CC/nn_ang_norm/100.00'] = {'max': 63.10090254388156, 'min': 4.1244047213558588} # lost: 0
limits['HS_tran/CC/nn_ang_norm/95.00'] = {'max': 39.378275858214948, 'min': 4.1244047213558588} # lost: 20
limits['HS_tran/CC/nn_ang_norm/99.00'] = {'max': 43.928739128574193, 'min': 4.1244047213558588} # lost: 4
limits['HS_tran/CC/nn_ang_norm/99.50'] = {'max': 45.917977082827036, 'min': 4.1244047213558588} # lost: 2
limits['HS_tran/CC/nn_ang_norm/99.90'] = {'max': 63.10090254388156, 'min': 4.1244047213558588} # lost: 0
limits['HS_tran/CC/nn_ang_norm/99.99'] = {'max': 63.10090254388156, 'min': 4.1244047213558588} # lost: 0
limits['HS_tran/CC/rot_ang/100.00'] = {'max': 120.89914749690053, 'min': 69.703072148763411} # lost: 0
limits['HS_tran/CC/rot_ang/95.00'] = {'max': 108.05802331532291, 'min': 75.560416394652123} # lost: 20
limits['HS_tran/CC/rot_ang/99.00'] = {'max': 110.76693845616121, 'min': 70.844404414336111} # lost: 4
limits['HS_tran/CC/rot_ang/99.50'] = {'max': 111.84122545066828, 'min': 69.85730862363981} # lost: 2
limits['HS_tran/CC/rot_ang/99.90'] = {'max': 120.89914749690053, 'min': 69.703072148763411} # lost: 0
limits['HS_tran/CC/rot_ang/99.99'] = {'max': 120.89914749690053, 'min': 69.703072148763411} # lost: 0
limits['HS_tran/CG/dist/100.00'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['HS_tran/CG/dist/95.00'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['HS_tran/CG/dist/99.00'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['HS_tran/CG/dist/99.50'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['HS_tran/CG/dist/99.90'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['HS_tran/CG/dist/99.99'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['HS_tran/CG/min_dist/100.00'] = {'max': 1.7351690348144468, 'min': 1.0813042726117885} # lost: 0
limits['HS_tran/CG/min_dist/95.00'] = {'max': 1.7351690348144468, 'min': 1.0813042726117885} # lost: 0
limits['HS_tran/CG/min_dist/99.00'] = {'max': 1.7351690348144468, 'min': 1.0813042726117885} # lost: 0
limits['HS_tran/CG/min_dist/99.50'] = {'max': 1.7351690348144468, 'min': 1.0813042726117885} # lost: 0
limits['HS_tran/CG/min_dist/99.90'] = {'max': 1.7351690348144468, 'min': 1.0813042726117885} # lost: 0
limits['HS_tran/CG/min_dist/99.99'] = {'max': 1.7351690348144468, 'min': 1.0813042726117885} # lost: 0
limits['HS_tran/CG/n2_z/100.00'] = {'max': -0.47715163, 'min': -0.99881917} # lost: 0
limits['HS_tran/CG/n2_z/95.00'] = {'max': -0.47715163, 'min': -0.99881917} # lost: 0
limits['HS_tran/CG/n2_z/99.00'] = {'max': -0.47715163, 'min': -0.99881917} # lost: 0
limits['HS_tran/CG/n2_z/99.50'] = {'max': -0.47715163, 'min': -0.99881917} # lost: 0
limits['HS_tran/CG/n2_z/99.90'] = {'max': -0.47715163, 'min': -0.99881917} # lost: 0
limits['HS_tran/CG/n2_z/99.99'] = {'max': -0.47715163, 'min': -0.99881917} # lost: 0
limits['HS_tran/CG/nn_ang_norm/100.00'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['HS_tran/CG/nn_ang_norm/95.00'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['HS_tran/CG/nn_ang_norm/99.00'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['HS_tran/CG/nn_ang_norm/99.50'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['HS_tran/CG/nn_ang_norm/99.90'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['HS_tran/CG/nn_ang_norm/99.99'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['HS_tran/CG/rot_ang/100.00'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['HS_tran/CG/rot_ang/95.00'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['HS_tran/CG/rot_ang/99.00'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['HS_tran/CG/rot_ang/99.50'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['HS_tran/CG/rot_ang/99.90'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['HS_tran/CG/rot_ang/99.99'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['HS_tran/CU/dist/100.00'] = {'max': 7.8021266423362592, 'min': 6.4523862439734927} # lost: 0
limits['HS_tran/CU/dist/95.00'] = {'max': 7.7213933394205414, 'min': 6.9077865250381665} # lost: 18
limits['HS_tran/CU/dist/99.00'] = {'max': 7.7948307483885841, 'min': 6.4524516236510614} # lost: 3
limits['HS_tran/CU/dist/99.50'] = {'max': 7.79732740743533, 'min': 6.4523862439734927} # lost: 1
limits['HS_tran/CU/dist/99.90'] = {'max': 7.8021266423362592, 'min': 6.4523862439734927} # lost: 0
limits['HS_tran/CU/dist/99.99'] = {'max': 7.8021266423362592, 'min': 6.4523862439734927} # lost: 0
limits['HS_tran/CU/min_dist/100.00'] = {'max': 2.3487499726582453, 'min': 1.3779106895008837} # lost: 0
limits['HS_tran/CU/min_dist/95.00'] = {'max': 2.1774936317570415, 'min': 1.5768649906976204} # lost: 18
limits['HS_tran/CU/min_dist/99.00'] = {'max': 2.224855109934492, 'min': 1.4024732671664006} # lost: 3
limits['HS_tran/CU/min_dist/99.50'] = {'max': 2.2604697000414946, 'min': 1.3779106895008837} # lost: 1
limits['HS_tran/CU/min_dist/99.90'] = {'max': 2.3487499726582453, 'min': 1.3779106895008837} # lost: 0
limits['HS_tran/CU/min_dist/99.99'] = {'max': 2.3487499726582453, 'min': 1.3779106895008837} # lost: 0
limits['HS_tran/CU/n2_z/100.00'] = {'max': -0.57937229, 'min': -0.99995977} # lost: 0
limits['HS_tran/CU/n2_z/95.00'] = {'max': -0.75438595, 'min': -0.99995977} # lost: 18
limits['HS_tran/CU/n2_z/99.00'] = {'max': -0.69577032, 'min': -0.99995977} # lost: 3
limits['HS_tran/CU/n2_z/99.50'] = {'max': -0.69365627, 'min': -0.99995977} # lost: 1
limits['HS_tran/CU/n2_z/99.90'] = {'max': -0.57937229, 'min': -0.99995977} # lost: 0
limits['HS_tran/CU/n2_z/99.99'] = {'max': -0.57937229, 'min': -0.99995977} # lost: 0
limits['HS_tran/CU/nn_ang_norm/100.00'] = {'max': 48.537996667308931, 'min': 0.7263173073828284} # lost: 0
limits['HS_tran/CU/nn_ang_norm/95.00'] = {'max': 41.489118500450701, 'min': 0.7263173073828284} # lost: 18
limits['HS_tran/CU/nn_ang_norm/99.00'] = {'max': 45.457758936551585, 'min': 0.7263173073828284} # lost: 3
limits['HS_tran/CU/nn_ang_norm/99.50'] = {'max': 46.831036771074366, 'min': 0.7263173073828284} # lost: 1
limits['HS_tran/CU/nn_ang_norm/99.90'] = {'max': 48.537996667308931, 'min': 0.7263173073828284} # lost: 0
limits['HS_tran/CU/nn_ang_norm/99.99'] = {'max': 48.537996667308931, 'min': 0.7263173073828284} # lost: 0
limits['HS_tran/CU/rot_ang/100.00'] = {'max': 120.9978939499244, 'min': 67.503945484387401} # lost: 0
limits['HS_tran/CU/rot_ang/95.00'] = {'max': 113.38182120892549, 'min': 70.937937163284985} # lost: 18
limits['HS_tran/CU/rot_ang/99.00'] = {'max': 119.97280912581418, 'min': 67.834709608276796} # lost: 3
limits['HS_tran/CU/rot_ang/99.50'] = {'max': 120.11012846715828, 'min': 67.503945484387401} # lost: 1
limits['HS_tran/CU/rot_ang/99.90'] = {'max': 120.9978939499244, 'min': 67.503945484387401} # lost: 0
limits['HS_tran/CU/rot_ang/99.99'] = {'max': 120.9978939499244, 'min': 67.503945484387401} # lost: 0
limits['HS_tran/GA/dist/100.00'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['HS_tran/GA/dist/95.00'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['HS_tran/GA/dist/99.00'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['HS_tran/GA/dist/99.50'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['HS_tran/GA/dist/99.90'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['HS_tran/GA/dist/99.99'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['HS_tran/GA/min_dist/100.00'] = {'max': 2.8707396926937583, 'min': 2.8707396926937583} # lost: 0
limits['HS_tran/GA/min_dist/95.00'] = {'max': 2.8707396926937583, 'min': 2.8707396926937583} # lost: 0
limits['HS_tran/GA/min_dist/99.00'] = {'max': 2.8707396926937583, 'min': 2.8707396926937583} # lost: 0
limits['HS_tran/GA/min_dist/99.50'] = {'max': 2.8707396926937583, 'min': 2.8707396926937583} # lost: 0
limits['HS_tran/GA/min_dist/99.90'] = {'max': 2.8707396926937583, 'min': 2.8707396926937583} # lost: 0
limits['HS_tran/GA/min_dist/99.99'] = {'max': 2.8707396926937583, 'min': 2.8707396926937583} # lost: 0
limits['HS_tran/GA/n2_z/100.00'] = {'max': -0.99937373, 'min': -0.99937373} # lost: 0
limits['HS_tran/GA/n2_z/95.00'] = {'max': -0.99937373, 'min': -0.99937373} # lost: 0
limits['HS_tran/GA/n2_z/99.00'] = {'max': -0.99937373, 'min': -0.99937373} # lost: 0
limits['HS_tran/GA/n2_z/99.50'] = {'max': -0.99937373, 'min': -0.99937373} # lost: 0
limits['HS_tran/GA/n2_z/99.90'] = {'max': -0.99937373, 'min': -0.99937373} # lost: 0
limits['HS_tran/GA/n2_z/99.99'] = {'max': -0.99937373, 'min': -0.99937373} # lost: 0
limits['HS_tran/GA/nn_ang_norm/100.00'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['HS_tran/GA/nn_ang_norm/95.00'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['HS_tran/GA/nn_ang_norm/99.00'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['HS_tran/GA/nn_ang_norm/99.50'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['HS_tran/GA/nn_ang_norm/99.90'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['HS_tran/GA/nn_ang_norm/99.99'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['HS_tran/GA/rot_ang/100.00'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['HS_tran/GA/rot_ang/95.00'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['HS_tran/GA/rot_ang/99.00'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['HS_tran/GA/rot_ang/99.50'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['HS_tran/GA/rot_ang/99.90'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['HS_tran/GA/rot_ang/99.99'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['HS_tran/GC/dist/100.00'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['HS_tran/GC/dist/95.00'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['HS_tran/GC/dist/99.00'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['HS_tran/GC/dist/99.50'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['HS_tran/GC/dist/99.90'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['HS_tran/GC/dist/99.99'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['HS_tran/GC/min_dist/100.00'] = {'max': 2.9387302525768537, 'min': 2.9387302525768537} # lost: 0
limits['HS_tran/GC/min_dist/95.00'] = {'max': 2.9387302525768537, 'min': 2.9387302525768537} # lost: 0
limits['HS_tran/GC/min_dist/99.00'] = {'max': 2.9387302525768537, 'min': 2.9387302525768537} # lost: 0
limits['HS_tran/GC/min_dist/99.50'] = {'max': 2.9387302525768537, 'min': 2.9387302525768537} # lost: 0
limits['HS_tran/GC/min_dist/99.90'] = {'max': 2.9387302525768537, 'min': 2.9387302525768537} # lost: 0
limits['HS_tran/GC/min_dist/99.99'] = {'max': 2.9387302525768537, 'min': 2.9387302525768537} # lost: 0
limits['HS_tran/GC/n2_z/100.00'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['HS_tran/GC/n2_z/95.00'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['HS_tran/GC/n2_z/99.00'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['HS_tran/GC/n2_z/99.50'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['HS_tran/GC/n2_z/99.90'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['HS_tran/GC/n2_z/99.99'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['HS_tran/GC/nn_ang_norm/100.00'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['HS_tran/GC/nn_ang_norm/95.00'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['HS_tran/GC/nn_ang_norm/99.00'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['HS_tran/GC/nn_ang_norm/99.50'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['HS_tran/GC/nn_ang_norm/99.90'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['HS_tran/GC/nn_ang_norm/99.99'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['HS_tran/GC/rot_ang/100.00'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['HS_tran/GC/rot_ang/95.00'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['HS_tran/GC/rot_ang/99.00'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['HS_tran/GC/rot_ang/99.50'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['HS_tran/GC/rot_ang/99.90'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['HS_tran/GC/rot_ang/99.99'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['HS_tran/GG/dist/100.00'] = {'max': 8.1931136970471581, 'min': 6.277946328901379} # lost: 0
limits['HS_tran/GG/dist/95.00'] = {'max': 7.7899810548276465, 'min': 6.6329068668250963} # lost: 56
limits['HS_tran/GG/dist/99.00'] = {'max': 7.9479992081015354, 'min': 6.4396007132297104} # lost: 11
limits['HS_tran/GG/dist/99.50'] = {'max': 8.0183345994110056, 'min': 6.3721044562883851} # lost: 5
limits['HS_tran/GG/dist/99.90'] = {'max': 8.1223310129372432, 'min': 6.277946328901379} # lost: 1
limits['HS_tran/GG/dist/99.99'] = {'max': 8.1931136970471581, 'min': 6.277946328901379} # lost: 0
limits['HS_tran/GG/min_dist/100.00'] = {'max': 2.8986073080708699, 'min': 1.240973703740434} # lost: 0
limits['HS_tran/GG/min_dist/95.00'] = {'max': 2.5144923462689781, 'min': 1.5297651555446294} # lost: 56
limits['HS_tran/GG/min_dist/99.00'] = {'max': 2.7486980723771599, 'min': 1.3314108919109431} # lost: 11
limits['HS_tran/GG/min_dist/99.50'] = {'max': 2.8433143153711828, 'min': 1.2808203805060714} # lost: 5
limits['HS_tran/GG/min_dist/99.90'] = {'max': 2.8911965935056108, 'min': 1.240973703740434} # lost: 1
limits['HS_tran/GG/min_dist/99.99'] = {'max': 2.8986073080708699, 'min': 1.240973703740434} # lost: 0
limits['HS_tran/GG/n2_z/100.00'] = {'max': -0.44574165, 'min': -0.99988687} # lost: 0
limits['HS_tran/GG/n2_z/95.00'] = {'max': -0.82104737, 'min': -0.99988687} # lost: 56
limits['HS_tran/GG/n2_z/99.00'] = {'max': -0.71918333, 'min': -0.99988687} # lost: 11
limits['HS_tran/GG/n2_z/99.50'] = {'max': -0.71336895, 'min': -0.99988687} # lost: 5
limits['HS_tran/GG/n2_z/99.90'] = {'max': -0.58754486, 'min': -0.99988687} # lost: 1
limits['HS_tran/GG/n2_z/99.99'] = {'max': -0.44574165, 'min': -0.99988687} # lost: 0
limits['HS_tran/GG/nn_ang_norm/100.00'] = {'max': 63.137225489887697, 'min': 0.79892221826005994} # lost: 0
limits['HS_tran/GG/nn_ang_norm/95.00'] = {'max': 34.150244161812083, 'min': 0.79892221826005994} # lost: 56
limits['HS_tran/GG/nn_ang_norm/99.00'] = {'max': 44.326543006214081, 'min': 0.79892221826005994} # lost: 11
limits['HS_tran/GG/nn_ang_norm/99.50'] = {'max': 44.637384915341357, 'min': 0.79892221826005994} # lost: 5
limits['HS_tran/GG/nn_ang_norm/99.90'] = {'max': 54.04150355331673, 'min': 0.79892221826005994} # lost: 1
limits['HS_tran/GG/nn_ang_norm/99.99'] = {'max': 63.137225489887697, 'min': 0.79892221826005994} # lost: 0
limits['HS_tran/GG/rot_ang/100.00'] = {'max': 119.85853183721325, 'min': 60.690121418434728} # lost: 0
limits['HS_tran/GG/rot_ang/95.00'] = {'max': 104.15002334469499, 'min': 66.857235293711142} # lost: 56
limits['HS_tran/GG/rot_ang/99.00'] = {'max': 109.47634007237932, 'min': 62.984509415425151} # lost: 11
limits['HS_tran/GG/rot_ang/99.50'] = {'max': 112.46699444490473, 'min': 61.922933605663175} # lost: 5
limits['HS_tran/GG/rot_ang/99.90'] = {'max': 115.46303250878387, 'min': 60.690121418434728} # lost: 1
limits['HS_tran/GG/rot_ang/99.99'] = {'max': 119.85853183721325, 'min': 60.690121418434728} # lost: 0
limits['HS_tran/GU/dist/100.00'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['HS_tran/GU/dist/95.00'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['HS_tran/GU/dist/99.00'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['HS_tran/GU/dist/99.50'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['HS_tran/GU/dist/99.90'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['HS_tran/GU/dist/99.99'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['HS_tran/GU/min_dist/100.00'] = {'max': 2.9590622153677693, 'min': 2.9590622153677693} # lost: 0
limits['HS_tran/GU/min_dist/95.00'] = {'max': 2.9590622153677693, 'min': 2.9590622153677693} # lost: 0
limits['HS_tran/GU/min_dist/99.00'] = {'max': 2.9590622153677693, 'min': 2.9590622153677693} # lost: 0
limits['HS_tran/GU/min_dist/99.50'] = {'max': 2.9590622153677693, 'min': 2.9590622153677693} # lost: 0
limits['HS_tran/GU/min_dist/99.90'] = {'max': 2.9590622153677693, 'min': 2.9590622153677693} # lost: 0
limits['HS_tran/GU/min_dist/99.99'] = {'max': 2.9590622153677693, 'min': 2.9590622153677693} # lost: 0
limits['HS_tran/GU/n2_z/100.00'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['HS_tran/GU/n2_z/95.00'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['HS_tran/GU/n2_z/99.00'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['HS_tran/GU/n2_z/99.50'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['HS_tran/GU/n2_z/99.90'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['HS_tran/GU/n2_z/99.99'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['HS_tran/GU/nn_ang_norm/100.00'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['HS_tran/GU/nn_ang_norm/95.00'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['HS_tran/GU/nn_ang_norm/99.00'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['HS_tran/GU/nn_ang_norm/99.50'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['HS_tran/GU/nn_ang_norm/99.90'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['HS_tran/GU/nn_ang_norm/99.99'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['HS_tran/GU/rot_ang/100.00'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['HS_tran/GU/rot_ang/95.00'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['HS_tran/GU/rot_ang/99.00'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['HS_tran/GU/rot_ang/99.50'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['HS_tran/GU/rot_ang/99.90'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['HS_tran/GU/rot_ang/99.99'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['HS_tran/UA/dist/100.00'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['HS_tran/UA/dist/95.00'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['HS_tran/UA/dist/99.00'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['HS_tran/UA/dist/99.50'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['HS_tran/UA/dist/99.90'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['HS_tran/UA/dist/99.99'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['HS_tran/UA/min_dist/100.00'] = {'max': 2.5563858206701933, 'min': 2.5563858206701933} # lost: 0
limits['HS_tran/UA/min_dist/95.00'] = {'max': 2.5563858206701933, 'min': 2.5563858206701933} # lost: 0
limits['HS_tran/UA/min_dist/99.00'] = {'max': 2.5563858206701933, 'min': 2.5563858206701933} # lost: 0
limits['HS_tran/UA/min_dist/99.50'] = {'max': 2.5563858206701933, 'min': 2.5563858206701933} # lost: 0
limits['HS_tran/UA/min_dist/99.90'] = {'max': 2.5563858206701933, 'min': 2.5563858206701933} # lost: 0
limits['HS_tran/UA/min_dist/99.99'] = {'max': 2.5563858206701933, 'min': 2.5563858206701933} # lost: 0
limits['HS_tran/UA/n2_z/100.00'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['HS_tran/UA/n2_z/95.00'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['HS_tran/UA/n2_z/99.00'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['HS_tran/UA/n2_z/99.50'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['HS_tran/UA/n2_z/99.90'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['HS_tran/UA/n2_z/99.99'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['HS_tran/UA/nn_ang_norm/100.00'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['HS_tran/UA/nn_ang_norm/95.00'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['HS_tran/UA/nn_ang_norm/99.00'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['HS_tran/UA/nn_ang_norm/99.50'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['HS_tran/UA/nn_ang_norm/99.90'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['HS_tran/UA/nn_ang_norm/99.99'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['HS_tran/UA/rot_ang/100.00'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['HS_tran/UA/rot_ang/95.00'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['HS_tran/UA/rot_ang/99.00'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['HS_tran/UA/rot_ang/99.50'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['HS_tran/UA/rot_ang/99.90'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['HS_tran/UA/rot_ang/99.99'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['HS_tran/UC/dist/100.00'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['HS_tran/UC/dist/95.00'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['HS_tran/UC/dist/99.00'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['HS_tran/UC/dist/99.50'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['HS_tran/UC/dist/99.90'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['HS_tran/UC/dist/99.99'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['HS_tran/UC/min_dist/100.00'] = {'max': 2.8154510256191743, 'min': 2.8154510256191743} # lost: 0
limits['HS_tran/UC/min_dist/95.00'] = {'max': 2.8154510256191743, 'min': 2.8154510256191743} # lost: 0
limits['HS_tran/UC/min_dist/99.00'] = {'max': 2.8154510256191743, 'min': 2.8154510256191743} # lost: 0
limits['HS_tran/UC/min_dist/99.50'] = {'max': 2.8154510256191743, 'min': 2.8154510256191743} # lost: 0
limits['HS_tran/UC/min_dist/99.90'] = {'max': 2.8154510256191743, 'min': 2.8154510256191743} # lost: 0
limits['HS_tran/UC/min_dist/99.99'] = {'max': 2.8154510256191743, 'min': 2.8154510256191743} # lost: 0
limits['HS_tran/UC/n2_z/100.00'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['HS_tran/UC/n2_z/95.00'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['HS_tran/UC/n2_z/99.00'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['HS_tran/UC/n2_z/99.50'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['HS_tran/UC/n2_z/99.90'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['HS_tran/UC/n2_z/99.99'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['HS_tran/UC/nn_ang_norm/100.00'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['HS_tran/UC/nn_ang_norm/95.00'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['HS_tran/UC/nn_ang_norm/99.00'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['HS_tran/UC/nn_ang_norm/99.50'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['HS_tran/UC/nn_ang_norm/99.90'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['HS_tran/UC/nn_ang_norm/99.99'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['HS_tran/UC/rot_ang/100.00'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['HS_tran/UC/rot_ang/95.00'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['HS_tran/UC/rot_ang/99.00'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['HS_tran/UC/rot_ang/99.50'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['HS_tran/UC/rot_ang/99.90'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['HS_tran/UC/rot_ang/99.99'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['HS_tran/UG/dist/100.00'] = {'max': 8.0614286471138374, 'min': 6.4028904664831163} # lost: 0
limits['HS_tran/UG/dist/95.00'] = {'max': 7.6821407323726953, 'min': 6.7639074289048819} # lost: 47
limits['HS_tran/UG/dist/99.00'] = {'max': 7.8526733854304762, 'min': 6.6201424027912541} # lost: 9
limits['HS_tran/UG/dist/99.50'] = {'max': 7.9192278656518518, 'min': 6.4546538614586035} # lost: 4
limits['HS_tran/UG/dist/99.90'] = {'max': 8.0614286471138374, 'min': 6.4028904664831163} # lost: 0
limits['HS_tran/UG/dist/99.99'] = {'max': 8.0614286471138374, 'min': 6.4028904664831163} # lost: 0
limits['HS_tran/UG/min_dist/100.00'] = {'max': 2.5469830324680061, 'min': 1.1452356043342857} # lost: 0
limits['HS_tran/UG/min_dist/95.00'] = {'max': 2.3225906133676539, 'min': 1.5034762538219508} # lost: 47
limits['HS_tran/UG/min_dist/99.00'] = {'max': 2.4761613959733388, 'min': 1.3593579144102588} # lost: 9
limits['HS_tran/UG/min_dist/99.50'] = {'max': 2.4838640370148859, 'min': 1.2514130558140366} # lost: 4
limits['HS_tran/UG/min_dist/99.90'] = {'max': 2.5469830324680061, 'min': 1.1452356043342857} # lost: 0
limits['HS_tran/UG/min_dist/99.99'] = {'max': 2.5469830324680061, 'min': 1.1452356043342857} # lost: 0
limits['HS_tran/UG/n2_z/100.00'] = {'max': -0.71290332, 'min': -0.99988288} # lost: 0
limits['HS_tran/UG/n2_z/95.00'] = {'max': -0.80050677, 'min': -0.99988288} # lost: 47
limits['HS_tran/UG/n2_z/99.00'] = {'max': -0.75430238, 'min': -0.99988288} # lost: 9
limits['HS_tran/UG/n2_z/99.50'] = {'max': -0.72539335, 'min': -0.99988288} # lost: 4
limits['HS_tran/UG/n2_z/99.90'] = {'max': -0.71290332, 'min': -0.99988288} # lost: 0
limits['HS_tran/UG/n2_z/99.99'] = {'max': -0.71290332, 'min': -0.99988288} # lost: 0
limits['HS_tran/UG/nn_ang_norm/100.00'] = {'max': 44.993415356017437, 'min': 0.086232959504258133} # lost: 0
limits['HS_tran/UG/nn_ang_norm/95.00'] = {'max': 36.825205787977524, 'min': 0.086232959504258133} # lost: 47
limits['HS_tran/UG/nn_ang_norm/99.00'] = {'max': 40.506213297750833, 'min': 0.086232959504258133} # lost: 9
limits['HS_tran/UG/nn_ang_norm/99.50'] = {'max': 41.996560574647617, 'min': 0.086232959504258133} # lost: 4
limits['HS_tran/UG/nn_ang_norm/99.90'] = {'max': 44.993415356017437, 'min': 0.086232959504258133} # lost: 0
limits['HS_tran/UG/nn_ang_norm/99.99'] = {'max': 44.993415356017437, 'min': 0.086232959504258133} # lost: 0
limits['HS_tran/UG/rot_ang/100.00'] = {'max': 127.68598065177342, 'min': 48.582855550616202} # lost: 0
limits['HS_tran/UG/rot_ang/95.00'] = {'max': 104.47754635763255, 'min': 61.86811707004383} # lost: 47
limits['HS_tran/UG/rot_ang/99.00'] = {'max': 113.13102830469796, 'min': 59.001141957459005} # lost: 9
limits['HS_tran/UG/rot_ang/99.50'] = {'max': 116.41035064666964, 'min': 52.833071024690845} # lost: 4
limits['HS_tran/UG/rot_ang/99.90'] = {'max': 127.68598065177342, 'min': 48.582855550616202} # lost: 0
limits['HS_tran/UG/rot_ang/99.99'] = {'max': 127.68598065177342, 'min': 48.582855550616202} # lost: 0
limits['HS_tran/UU/dist/100.00'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['HS_tran/UU/dist/95.00'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['HS_tran/UU/dist/99.00'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['HS_tran/UU/dist/99.50'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['HS_tran/UU/dist/99.90'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['HS_tran/UU/dist/99.99'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['HS_tran/UU/min_dist/100.00'] = {'max': 3.1795851446819343, 'min': 3.1795851446819343} # lost: 0
limits['HS_tran/UU/min_dist/95.00'] = {'max': 3.1795851446819343, 'min': 3.1795851446819343} # lost: 0
limits['HS_tran/UU/min_dist/99.00'] = {'max': 3.1795851446819343, 'min': 3.1795851446819343} # lost: 0
limits['HS_tran/UU/min_dist/99.50'] = {'max': 3.1795851446819343, 'min': 3.1795851446819343} # lost: 0
limits['HS_tran/UU/min_dist/99.90'] = {'max': 3.1795851446819343, 'min': 3.1795851446819343} # lost: 0
limits['HS_tran/UU/min_dist/99.99'] = {'max': 3.1795851446819343, 'min': 3.1795851446819343} # lost: 0
limits['HS_tran/UU/n2_z/100.00'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['HS_tran/UU/n2_z/95.00'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['HS_tran/UU/n2_z/99.00'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['HS_tran/UU/n2_z/99.50'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['HS_tran/UU/n2_z/99.90'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['HS_tran/UU/n2_z/99.99'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['HS_tran/UU/nn_ang_norm/100.00'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['HS_tran/UU/nn_ang_norm/95.00'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['HS_tran/UU/nn_ang_norm/99.00'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['HS_tran/UU/nn_ang_norm/99.50'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['HS_tran/UU/nn_ang_norm/99.90'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['HS_tran/UU/nn_ang_norm/99.99'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['HS_tran/UU/rot_ang/100.00'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['HS_tran/UU/rot_ang/95.00'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['HS_tran/UU/rot_ang/99.00'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['HS_tran/UU/rot_ang/99.50'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['HS_tran/UU/rot_ang/99.90'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['HS_tran/UU/rot_ang/99.99'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['HW_cis/AA/dist/100.00'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['HW_cis/AA/dist/95.00'] = {'max': 7.7579640403216139, 'min': 5.8754347620220493} # lost: 4
limits['HW_cis/AA/dist/99.00'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['HW_cis/AA/dist/99.50'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['HW_cis/AA/dist/99.90'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['HW_cis/AA/dist/99.99'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['HW_cis/AA/min_dist/100.00'] = {'max': 2.5200282601543549, 'min': 0.97690143662888262} # lost: 0
limits['HW_cis/AA/min_dist/95.00'] = {'max': 2.3301599591062638, 'min': 1.0319684734385939} # lost: 4
limits['HW_cis/AA/min_dist/99.00'] = {'max': 2.5200282601543549, 'min': 0.97690143662888262} # lost: 0
limits['HW_cis/AA/min_dist/99.50'] = {'max': 2.5200282601543549, 'min': 0.97690143662888262} # lost: 0
limits['HW_cis/AA/min_dist/99.90'] = {'max': 2.5200282601543549, 'min': 0.97690143662888262} # lost: 0
limits['HW_cis/AA/min_dist/99.99'] = {'max': 2.5200282601543549, 'min': 0.97690143662888262} # lost: 0
limits['HW_cis/AA/n2_z/100.00'] = {'max': 0.99825132, 'min': 0.62279785} # lost: 0
limits['HW_cis/AA/n2_z/95.00'] = {'max': 0.99825132, 'min': 0.64609915} # lost: 4
limits['HW_cis/AA/n2_z/99.00'] = {'max': 0.99825132, 'min': 0.62279785} # lost: 0
limits['HW_cis/AA/n2_z/99.50'] = {'max': 0.99825132, 'min': 0.62279785} # lost: 0
limits['HW_cis/AA/n2_z/99.90'] = {'max': 0.99825132, 'min': 0.62279785} # lost: 0
limits['HW_cis/AA/n2_z/99.99'] = {'max': 0.99825132, 'min': 0.62279785} # lost: 0
limits['HW_cis/AA/nn_ang_norm/100.00'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['HW_cis/AA/nn_ang_norm/95.00'] = {'max': 48.162593988913841, 'min': 2.3997987042716158} # lost: 4
limits['HW_cis/AA/nn_ang_norm/99.00'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['HW_cis/AA/nn_ang_norm/99.50'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['HW_cis/AA/nn_ang_norm/99.90'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['HW_cis/AA/nn_ang_norm/99.99'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['HW_cis/AA/rot_ang/100.00'] = {'max2': -59.634707805547464, 'min1': 230.25152153163739, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AA/rot_ang/95.00'] = {'max2': -63.723112053839145, 'min1': 235.25698356163306, 'min2': -90.0, 'max1': 270.0} # lost: 4
limits['HW_cis/AA/rot_ang/99.00'] = {'max2': -59.634707805547464, 'min1': 230.25152153163739, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AA/rot_ang/99.50'] = {'max2': -59.634707805547464, 'min1': 230.25152153163739, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AA/rot_ang/99.90'] = {'max2': -59.634707805547464, 'min1': 230.25152153163739, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AA/rot_ang/99.99'] = {'max2': -59.634707805547464, 'min1': 230.25152153163739, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AC/dist/100.00'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['HW_cis/AC/dist/95.00'] = {'max': 8.0006603962441716, 'min': 5.7913702957757174} # lost: 1
limits['HW_cis/AC/dist/99.00'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['HW_cis/AC/dist/99.50'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['HW_cis/AC/dist/99.90'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['HW_cis/AC/dist/99.99'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['HW_cis/AC/min_dist/100.00'] = {'max': 2.4600786682808797, 'min': 1.3053185543667698} # lost: 0
limits['HW_cis/AC/min_dist/95.00'] = {'max': 2.4512778158015136, 'min': 1.3053185543667698} # lost: 1
limits['HW_cis/AC/min_dist/99.00'] = {'max': 2.4600786682808797, 'min': 1.3053185543667698} # lost: 0
limits['HW_cis/AC/min_dist/99.50'] = {'max': 2.4600786682808797, 'min': 1.3053185543667698} # lost: 0
limits['HW_cis/AC/min_dist/99.90'] = {'max': 2.4600786682808797, 'min': 1.3053185543667698} # lost: 0
limits['HW_cis/AC/min_dist/99.99'] = {'max': 2.4600786682808797, 'min': 1.3053185543667698} # lost: 0
limits['HW_cis/AC/n2_z/100.00'] = {'max': 0.99321824, 'min': 0.62758625} # lost: 0
limits['HW_cis/AC/n2_z/95.00'] = {'max': 0.99321824, 'min': 0.76705486} # lost: 1
limits['HW_cis/AC/n2_z/99.00'] = {'max': 0.99321824, 'min': 0.62758625} # lost: 0
limits['HW_cis/AC/n2_z/99.50'] = {'max': 0.99321824, 'min': 0.62758625} # lost: 0
limits['HW_cis/AC/n2_z/99.90'] = {'max': 0.99321824, 'min': 0.62758625} # lost: 0
limits['HW_cis/AC/n2_z/99.99'] = {'max': 0.99321824, 'min': 0.62758625} # lost: 0
limits['HW_cis/AC/nn_ang_norm/100.00'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['HW_cis/AC/nn_ang_norm/95.00'] = {'max': 41.031596457664563, 'min': 6.1326121316824169} # lost: 1
limits['HW_cis/AC/nn_ang_norm/99.00'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['HW_cis/AC/nn_ang_norm/99.50'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['HW_cis/AC/nn_ang_norm/99.90'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['HW_cis/AC/nn_ang_norm/99.99'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['HW_cis/AC/rot_ang/100.00'] = {'max2': -59.680556936211246, 'min1': 263.05868632171223, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AC/rot_ang/95.00'] = {'max2': -60.874700334966917, 'min1': 263.05868632171223, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/AC/rot_ang/99.00'] = {'max2': -59.680556936211246, 'min1': 263.05868632171223, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AC/rot_ang/99.50'] = {'max2': -59.680556936211246, 'min1': 263.05868632171223, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AC/rot_ang/99.90'] = {'max2': -59.680556936211246, 'min1': 263.05868632171223, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AC/rot_ang/99.99'] = {'max2': -59.680556936211246, 'min1': 263.05868632171223, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AG/dist/100.00'] = {'max': 7.243654811975631, 'min': 5.6796308184762001} # lost: 0
limits['HW_cis/AG/dist/95.00'] = {'max': 7.0649086831645942, 'min': 6.1370272057233866} # lost: 20
limits['HW_cis/AG/dist/99.00'] = {'max': 7.2068663716805732, 'min': 5.7222206548877104} # lost: 4
limits['HW_cis/AG/dist/99.50'] = {'max': 7.2152999955372037, 'min': 5.7047071016434749} # lost: 2
limits['HW_cis/AG/dist/99.90'] = {'max': 7.243654811975631, 'min': 5.6796308184762001} # lost: 0
limits['HW_cis/AG/dist/99.99'] = {'max': 7.243654811975631, 'min': 5.6796308184762001} # lost: 0
limits['HW_cis/AG/min_dist/100.00'] = {'max': 2.6479277843983553, 'min': 0.74850278261175041} # lost: 0
limits['HW_cis/AG/min_dist/95.00'] = {'max': 2.2816063678970067, 'min': 1.4610443902148325} # lost: 20
limits['HW_cis/AG/min_dist/99.00'] = {'max': 2.5042419053957801, 'min': 1.1885888971614282} # lost: 4
limits['HW_cis/AG/min_dist/99.50'] = {'max': 2.5154725122311841, 'min': 1.0558456921044939} # lost: 2
limits['HW_cis/AG/min_dist/99.90'] = {'max': 2.6479277843983553, 'min': 0.74850278261175041} # lost: 0
limits['HW_cis/AG/min_dist/99.99'] = {'max': 2.6479277843983553, 'min': 0.74850278261175041} # lost: 0
limits['HW_cis/AG/n2_z/100.00'] = {'max': 0.99993873, 'min': 0.44711134} # lost: 0
limits['HW_cis/AG/n2_z/95.00'] = {'max': 0.99993873, 'min': 0.63641912} # lost: 20
limits['HW_cis/AG/n2_z/99.00'] = {'max': 0.99993873, 'min': 0.55423427} # lost: 4
limits['HW_cis/AG/n2_z/99.50'] = {'max': 0.99993873, 'min': 0.52422917} # lost: 2
limits['HW_cis/AG/n2_z/99.90'] = {'max': 0.99993873, 'min': 0.44711134} # lost: 0
limits['HW_cis/AG/n2_z/99.99'] = {'max': 0.99993873, 'min': 0.44711134} # lost: 0
limits['HW_cis/AG/nn_ang_norm/100.00'] = {'max': 63.266218621319716, 'min': 0.50085046140018896} # lost: 0
limits['HW_cis/AG/nn_ang_norm/95.00'] = {'max': 51.261877702171752, 'min': 0.50085046140018896} # lost: 20
limits['HW_cis/AG/nn_ang_norm/99.00'] = {'max': 56.350894558397343, 'min': 0.50085046140018896} # lost: 4
limits['HW_cis/AG/nn_ang_norm/99.50'] = {'max': 58.699629274330064, 'min': 0.50085046140018896} # lost: 2
limits['HW_cis/AG/nn_ang_norm/99.90'] = {'max': 63.266218621319716, 'min': 0.50085046140018896} # lost: 0
limits['HW_cis/AG/nn_ang_norm/99.99'] = {'max': 63.266218621319716, 'min': 0.50085046140018896} # lost: 0
limits['HW_cis/AG/rot_ang/100.00'] = {'max2': -53.342609806569271, 'min1': 231.64184937778018, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AG/rot_ang/95.00'] = {'max2': -59.831795372990257, 'min1': 240.82391941381738, 'min2': -90.0, 'max1': 270.0} # lost: 20
limits['HW_cis/AG/rot_ang/99.00'] = {'max2': -53.739386840518193, 'min1': 235.46172440448709, 'min2': -90.0, 'max1': 270.0} # lost: 4
limits['HW_cis/AG/rot_ang/99.50'] = {'max2': -53.522326764083857, 'min1': 235.45907071381501, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HW_cis/AG/rot_ang/99.90'] = {'max2': -53.342609806569271, 'min1': 231.64184937778018, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AG/rot_ang/99.99'] = {'max2': -53.342609806569271, 'min1': 231.64184937778018, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AU/dist/100.00'] = {'max': 7.3416553014266057, 'min': 5.8520830719013661} # lost: 0
limits['HW_cis/AU/dist/95.00'] = {'max': 6.9670667527262014, 'min': 6.2138931830288753} # lost: 157
limits['HW_cis/AU/dist/99.00'] = {'max': 7.09455520294377, 'min': 6.0823972980757519} # lost: 31
limits['HW_cis/AU/dist/99.50'] = {'max': 7.189661263976916, 'min': 5.9780660760840663} # lost: 15
limits['HW_cis/AU/dist/99.90'] = {'max': 7.2711891935090183, 'min': 5.9300246547603299} # lost: 3
limits['HW_cis/AU/dist/99.99'] = {'max': 7.3416553014266057, 'min': 5.8520830719013661} # lost: 0
limits['HW_cis/AU/min_dist/100.00'] = {'max': 2.670199952003399, 'min': 1.1672451490170488} # lost: 0
limits['HW_cis/AU/min_dist/95.00'] = {'max': 2.3112531845577116, 'min': 1.573148427901137} # lost: 157
limits['HW_cis/AU/min_dist/99.00'] = {'max': 2.4566221811173978, 'min': 1.4547674801078474} # lost: 31
limits['HW_cis/AU/min_dist/99.50'] = {'max': 2.4944193033722053, 'min': 1.4246845646028714} # lost: 15
limits['HW_cis/AU/min_dist/99.90'] = {'max': 2.632554041314116, 'min': 1.1724879480038359} # lost: 3
limits['HW_cis/AU/min_dist/99.99'] = {'max': 2.670199952003399, 'min': 1.1672451490170488} # lost: 0
limits['HW_cis/AU/n2_z/100.00'] = {'max': 0.99992025, 'min': 0.4718422} # lost: 0
limits['HW_cis/AU/n2_z/95.00'] = {'max': 0.99992025, 'min': 0.762025} # lost: 157
limits['HW_cis/AU/n2_z/99.00'] = {'max': 0.99992025, 'min': 0.61358023} # lost: 31
limits['HW_cis/AU/n2_z/99.50'] = {'max': 0.99992025, 'min': 0.55534112} # lost: 15
limits['HW_cis/AU/n2_z/99.90'] = {'max': 0.99992025, 'min': 0.49557763} # lost: 3
limits['HW_cis/AU/n2_z/99.99'] = {'max': 0.99992025, 'min': 0.4718422} # lost: 0
limits['HW_cis/AU/nn_ang_norm/100.00'] = {'max': 61.471087813089454, 'min': 0.7190050493039567} # lost: 0
limits['HW_cis/AU/nn_ang_norm/95.00'] = {'max': 40.252924156431838, 'min': 0.7190050493039567} # lost: 157
limits['HW_cis/AU/nn_ang_norm/99.00'] = {'max': 52.142275425808059, 'min': 0.7190050493039567} # lost: 31
limits['HW_cis/AU/nn_ang_norm/99.50'] = {'max': 56.048498178178782, 'min': 0.7190050493039567} # lost: 15
limits['HW_cis/AU/nn_ang_norm/99.90'] = {'max': 59.800280108131766, 'min': 0.7190050493039567} # lost: 3
limits['HW_cis/AU/nn_ang_norm/99.99'] = {'max': 61.471087813089454, 'min': 0.7190050493039567} # lost: 0
limits['HW_cis/AU/rot_ang/100.00'] = {'max2': -37.950410170640339, 'min1': 239.08840735853701, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/AU/rot_ang/95.00'] = {'max2': -55.104395751392587, 'min1': 277.89428818749599, 'min2': -90.0, 'max1': 270.0} # lost: 157
limits['HW_cis/AU/rot_ang/99.00'] = {'max2': -49.291854041689078, 'min1': 263.76407563661638, 'min2': -90.0, 'max1': 270.0} # lost: 31
limits['HW_cis/AU/rot_ang/99.50'] = {'max2': -44.720017562883356, 'min1': 261.92465471689673, 'min2': -90.0, 'max1': 270.0} # lost: 15
limits['HW_cis/AU/rot_ang/99.90'] = {'max2': -40.142752132129658, 'min1': 239.238034240042, 'min2': -90.0, 'max1': 270.0} # lost: 3
limits['HW_cis/AU/rot_ang/99.99'] = {'max2': -37.950410170640339, 'min1': 239.08840735853701, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CA/dist/100.00'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['HW_cis/CA/dist/95.00'] = {'max': 6.3165742434447338, 'min': 5.1483252869825344} # lost: 1
limits['HW_cis/CA/dist/99.00'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['HW_cis/CA/dist/99.50'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['HW_cis/CA/dist/99.90'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['HW_cis/CA/dist/99.99'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['HW_cis/CA/min_dist/100.00'] = {'max': 2.125797502922214, 'min': 1.0337596670283595} # lost: 0
limits['HW_cis/CA/min_dist/95.00'] = {'max': 1.8910522219347037, 'min': 1.0337596670283595} # lost: 1
limits['HW_cis/CA/min_dist/99.00'] = {'max': 2.125797502922214, 'min': 1.0337596670283595} # lost: 0
limits['HW_cis/CA/min_dist/99.50'] = {'max': 2.125797502922214, 'min': 1.0337596670283595} # lost: 0
limits['HW_cis/CA/min_dist/99.90'] = {'max': 2.125797502922214, 'min': 1.0337596670283595} # lost: 0
limits['HW_cis/CA/min_dist/99.99'] = {'max': 2.125797502922214, 'min': 1.0337596670283595} # lost: 0
limits['HW_cis/CA/n2_z/100.00'] = {'max': 0.9995923, 'min': 0.7068978} # lost: 0
limits['HW_cis/CA/n2_z/95.00'] = {'max': 0.9995923, 'min': 0.97788149} # lost: 1
limits['HW_cis/CA/n2_z/99.00'] = {'max': 0.9995923, 'min': 0.7068978} # lost: 0
limits['HW_cis/CA/n2_z/99.50'] = {'max': 0.9995923, 'min': 0.7068978} # lost: 0
limits['HW_cis/CA/n2_z/99.90'] = {'max': 0.9995923, 'min': 0.7068978} # lost: 0
limits['HW_cis/CA/n2_z/99.99'] = {'max': 0.9995923, 'min': 0.7068978} # lost: 0
limits['HW_cis/CA/nn_ang_norm/100.00'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['HW_cis/CA/nn_ang_norm/95.00'] = {'max': 13.423793393780954, 'min': 1.5142656388748148} # lost: 1
limits['HW_cis/CA/nn_ang_norm/99.00'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['HW_cis/CA/nn_ang_norm/99.50'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['HW_cis/CA/nn_ang_norm/99.90'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['HW_cis/CA/nn_ang_norm/99.99'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['HW_cis/CA/rot_ang/100.00'] = {'max2': -62.302969299487415, 'min1': 260.34804521366902, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CA/rot_ang/95.00'] = {'max2': -63.360245022515983, 'min1': 260.34804521366902, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/CA/rot_ang/99.00'] = {'max2': -62.302969299487415, 'min1': 260.34804521366902, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CA/rot_ang/99.50'] = {'max2': -62.302969299487415, 'min1': 260.34804521366902, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CA/rot_ang/99.90'] = {'max2': -62.302969299487415, 'min1': 260.34804521366902, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CA/rot_ang/99.99'] = {'max2': -62.302969299487415, 'min1': 260.34804521366902, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CC/dist/100.00'] = {'max': 7.5238530109889368, 'min': 5.4808437869078119} # lost: 0
limits['HW_cis/CC/dist/95.00'] = {'max': 7.3677045762287383, 'min': 6.0275731480121273} # lost: 14
limits['HW_cis/CC/dist/99.00'] = {'max': 7.455351380237035, 'min': 5.6546137673570724} # lost: 2
limits['HW_cis/CC/dist/99.50'] = {'max': 7.455351380237035, 'min': 5.4808437869078119} # lost: 1
limits['HW_cis/CC/dist/99.90'] = {'max': 7.5238530109889368, 'min': 5.4808437869078119} # lost: 0
limits['HW_cis/CC/dist/99.99'] = {'max': 7.5238530109889368, 'min': 5.4808437869078119} # lost: 0
limits['HW_cis/CC/min_dist/100.00'] = {'max': 2.562230899766555, 'min': 0.71168851499818075} # lost: 0
limits['HW_cis/CC/min_dist/95.00'] = {'max': 2.3829318821820737, 'min': 1.5097448737870292} # lost: 14
limits['HW_cis/CC/min_dist/99.00'] = {'max': 2.4763284944810739, 'min': 0.97793787498371076} # lost: 2
limits['HW_cis/CC/min_dist/99.50'] = {'max': 2.4763284944810739, 'min': 0.71168851499818075} # lost: 1
limits['HW_cis/CC/min_dist/99.90'] = {'max': 2.562230899766555, 'min': 0.71168851499818075} # lost: 0
limits['HW_cis/CC/min_dist/99.99'] = {'max': 2.562230899766555, 'min': 0.71168851499818075} # lost: 0
limits['HW_cis/CC/n2_z/100.00'] = {'max': 0.9999699, 'min': 0.65428305} # lost: 0
limits['HW_cis/CC/n2_z/95.00'] = {'max': 0.9999699, 'min': 0.79952937} # lost: 14
limits['HW_cis/CC/n2_z/99.00'] = {'max': 0.9999699, 'min': 0.66771042} # lost: 2
limits['HW_cis/CC/n2_z/99.50'] = {'max': 0.9999699, 'min': 0.66705918} # lost: 1
limits['HW_cis/CC/n2_z/99.90'] = {'max': 0.9999699, 'min': 0.65428305} # lost: 0
limits['HW_cis/CC/n2_z/99.99'] = {'max': 0.9999699, 'min': 0.65428305} # lost: 0
limits['HW_cis/CC/nn_ang_norm/100.00'] = {'max': 50.466409965769977, 'min': 0.97437984595520966} # lost: 0
limits['HW_cis/CC/nn_ang_norm/95.00'] = {'max': 37.134553479538333, 'min': 0.97437984595520966} # lost: 14
limits['HW_cis/CC/nn_ang_norm/99.00'] = {'max': 47.090093779776346, 'min': 0.97437984595520966} # lost: 2
limits['HW_cis/CC/nn_ang_norm/99.50'] = {'max': 48.089429002524668, 'min': 0.97437984595520966} # lost: 1
limits['HW_cis/CC/nn_ang_norm/99.90'] = {'max': 50.466409965769977, 'min': 0.97437984595520966} # lost: 0
limits['HW_cis/CC/nn_ang_norm/99.99'] = {'max': 50.466409965769977, 'min': 0.97437984595520966} # lost: 0
limits['HW_cis/CC/rot_ang/100.00'] = {'max2': -36.545349040041003, 'min1': 263.37617271497311, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CC/rot_ang/95.00'] = {'max2': -38.675852068639301, 'min1': 266.63145092711039, 'min2': -90.0, 'max1': 270.0} # lost: 14
limits['HW_cis/CC/rot_ang/99.00'] = {'max2': -37.303665112384749, 'min1': 263.78355054939908, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HW_cis/CC/rot_ang/99.50'] = {'max2': -37.303665112384749, 'min1': 263.37617271497311, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/CC/rot_ang/99.90'] = {'max2': -36.545349040041003, 'min1': 263.37617271497311, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CC/rot_ang/99.99'] = {'max2': -36.545349040041003, 'min1': 263.37617271497311, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CG/dist/100.00'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['HW_cis/CG/dist/95.00'] = {'max': 5.551871893901577, 'min': 5.1034801209014216} # lost: 2
limits['HW_cis/CG/dist/99.00'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['HW_cis/CG/dist/99.50'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['HW_cis/CG/dist/99.90'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['HW_cis/CG/dist/99.99'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['HW_cis/CG/min_dist/100.00'] = {'max': 1.9903261122990881, 'min': 0.4377276284966603} # lost: 0
limits['HW_cis/CG/min_dist/95.00'] = {'max': 1.9879611939224899, 'min': 0.73051871661325096} # lost: 2
limits['HW_cis/CG/min_dist/99.00'] = {'max': 1.9903261122990881, 'min': 0.4377276284966603} # lost: 0
limits['HW_cis/CG/min_dist/99.50'] = {'max': 1.9903261122990881, 'min': 0.4377276284966603} # lost: 0
limits['HW_cis/CG/min_dist/99.90'] = {'max': 1.9903261122990881, 'min': 0.4377276284966603} # lost: 0
limits['HW_cis/CG/min_dist/99.99'] = {'max': 1.9903261122990881, 'min': 0.4377276284966603} # lost: 0
limits['HW_cis/CG/n2_z/100.00'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['HW_cis/CG/n2_z/95.00'] = {'max': 0.99842197, 'min': 0.60652155} # lost: 2
limits['HW_cis/CG/n2_z/99.00'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['HW_cis/CG/n2_z/99.50'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['HW_cis/CG/n2_z/99.90'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['HW_cis/CG/n2_z/99.99'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['HW_cis/CG/nn_ang_norm/100.00'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['HW_cis/CG/nn_ang_norm/95.00'] = {'max': 52.706933994682181, 'min': 3.2821118690832849} # lost: 2
limits['HW_cis/CG/nn_ang_norm/99.00'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['HW_cis/CG/nn_ang_norm/99.50'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['HW_cis/CG/nn_ang_norm/99.90'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['HW_cis/CG/nn_ang_norm/99.99'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['HW_cis/CG/rot_ang/100.00'] = {'max2': -67.189473574306305, 'min1': 210.30134047467558, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CG/rot_ang/95.00'] = {'max2': -70.163318634003076, 'min1': 270.61824314926696, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HW_cis/CG/rot_ang/99.00'] = {'max2': -67.189473574306305, 'min1': 210.30134047467558, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CG/rot_ang/99.50'] = {'max2': -67.189473574306305, 'min1': 210.30134047467558, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CG/rot_ang/99.90'] = {'max2': -67.189473574306305, 'min1': 210.30134047467558, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CG/rot_ang/99.99'] = {'max2': -67.189473574306305, 'min1': 210.30134047467558, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CU/dist/100.00'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['HW_cis/CU/dist/95.00'] = {'max': 7.4867185417475346, 'min': 5.4208483773788938} # lost: 9
limits['HW_cis/CU/dist/99.00'] = {'max': 7.5139163090787884, 'min': 5.2284493555345488} # lost: 1
limits['HW_cis/CU/dist/99.50'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['HW_cis/CU/dist/99.90'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['HW_cis/CU/dist/99.99'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['HW_cis/CU/min_dist/100.00'] = {'max': 2.4562307025203678, 'min': 0.99438919443004581} # lost: 0
limits['HW_cis/CU/min_dist/95.00'] = {'max': 2.3295621447982815, 'min': 1.0146075653395197} # lost: 9
limits['HW_cis/CU/min_dist/99.00'] = {'max': 2.3538427290486603, 'min': 0.99438919443004581} # lost: 1
limits['HW_cis/CU/min_dist/99.50'] = {'max': 2.4562307025203678, 'min': 0.99438919443004581} # lost: 0
limits['HW_cis/CU/min_dist/99.90'] = {'max': 2.4562307025203678, 'min': 0.99438919443004581} # lost: 0
limits['HW_cis/CU/min_dist/99.99'] = {'max': 2.4562307025203678, 'min': 0.99438919443004581} # lost: 0
limits['HW_cis/CU/n2_z/100.00'] = {'max': 0.99981862, 'min': 0.48384601} # lost: 0
limits['HW_cis/CU/n2_z/95.00'] = {'max': 0.99981862, 'min': 0.79980844} # lost: 9
limits['HW_cis/CU/n2_z/99.00'] = {'max': 0.99981862, 'min': 0.61452675} # lost: 1
limits['HW_cis/CU/n2_z/99.50'] = {'max': 0.99981862, 'min': 0.48384601} # lost: 0
limits['HW_cis/CU/n2_z/99.90'] = {'max': 0.99981862, 'min': 0.48384601} # lost: 0
limits['HW_cis/CU/n2_z/99.99'] = {'max': 0.99981862, 'min': 0.48384601} # lost: 0
limits['HW_cis/CU/nn_ang_norm/100.00'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['HW_cis/CU/nn_ang_norm/95.00'] = {'max': 37.153083782756575, 'min': 1.7634741620877215} # lost: 9
limits['HW_cis/CU/nn_ang_norm/99.00'] = {'max': 51.637445898968657, 'min': 1.7634741620877215} # lost: 1
limits['HW_cis/CU/nn_ang_norm/99.50'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['HW_cis/CU/nn_ang_norm/99.90'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['HW_cis/CU/nn_ang_norm/99.99'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['HW_cis/CU/rot_ang/100.00'] = {'max2': -41.896673133449553, 'min1': 244.12453438095463, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CU/rot_ang/95.00'] = {'max2': -44.876396673426825, 'min1': 251.47915240873516, 'min2': -90.0, 'max1': 270.0} # lost: 9
limits['HW_cis/CU/rot_ang/99.00'] = {'max2': -44.065944399815919, 'min1': 244.12453438095463, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/CU/rot_ang/99.50'] = {'max2': -41.896673133449553, 'min1': 244.12453438095463, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CU/rot_ang/99.90'] = {'max2': -41.896673133449553, 'min1': 244.12453438095463, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/CU/rot_ang/99.99'] = {'max2': -41.896673133449553, 'min1': 244.12453438095463, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GA/dist/100.00'] = {'max': 8.1134495997262963, 'min': 5.015281578181602} # lost: 0
limits['HW_cis/GA/dist/95.00'] = {'max': 8.0687093354999675, 'min': 6.0710787173748324} # lost: 13
limits['HW_cis/GA/dist/99.00'] = {'max': 8.1081760515085985, 'min': 5.3792820898830511} # lost: 2
limits['HW_cis/GA/dist/99.50'] = {'max': 8.1081760515085985, 'min': 5.015281578181602} # lost: 1
limits['HW_cis/GA/dist/99.90'] = {'max': 8.1134495997262963, 'min': 5.015281578181602} # lost: 0
limits['HW_cis/GA/dist/99.99'] = {'max': 8.1134495997262963, 'min': 5.015281578181602} # lost: 0
limits['HW_cis/GA/min_dist/100.00'] = {'max': 2.5427489260534282, 'min': 1.2694686887714777} # lost: 0
limits['HW_cis/GA/min_dist/95.00'] = {'max': 2.3376543406481414, 'min': 1.6223769186653956} # lost: 13
limits['HW_cis/GA/min_dist/99.00'] = {'max': 2.4908210194317646, 'min': 1.4498871098266046} # lost: 2
limits['HW_cis/GA/min_dist/99.50'] = {'max': 2.4908210194317646, 'min': 1.2694686887714777} # lost: 1
limits['HW_cis/GA/min_dist/99.90'] = {'max': 2.5427489260534282, 'min': 1.2694686887714777} # lost: 0
limits['HW_cis/GA/min_dist/99.99'] = {'max': 2.5427489260534282, 'min': 1.2694686887714777} # lost: 0
limits['HW_cis/GA/n2_z/100.00'] = {'max': 0.99936944, 'min': 0.44881296} # lost: 0
limits['HW_cis/GA/n2_z/95.00'] = {'max': 0.99936944, 'min': 0.77039391} # lost: 13
limits['HW_cis/GA/n2_z/99.00'] = {'max': 0.99936944, 'min': 0.56164801} # lost: 2
limits['HW_cis/GA/n2_z/99.50'] = {'max': 0.99936944, 'min': 0.50919354} # lost: 1
limits['HW_cis/GA/n2_z/99.90'] = {'max': 0.99936944, 'min': 0.44881296} # lost: 0
limits['HW_cis/GA/n2_z/99.99'] = {'max': 0.99936944, 'min': 0.44881296} # lost: 0
limits['HW_cis/GA/nn_ang_norm/100.00'] = {'max': 61.654013939440738, 'min': 2.2375590864821877} # lost: 0
limits['HW_cis/GA/nn_ang_norm/95.00'] = {'max': 39.65553190596043, 'min': 2.2375590864821877} # lost: 13
limits['HW_cis/GA/nn_ang_norm/99.00'] = {'max': 55.726232777664656, 'min': 2.2375590864821877} # lost: 2
limits['HW_cis/GA/nn_ang_norm/99.50'] = {'max': 59.488058500792143, 'min': 2.2375590864821877} # lost: 1
limits['HW_cis/GA/nn_ang_norm/99.90'] = {'max': 61.654013939440738, 'min': 2.2375590864821877} # lost: 0
limits['HW_cis/GA/nn_ang_norm/99.99'] = {'max': 61.654013939440738, 'min': 2.2375590864821877} # lost: 0
limits['HW_cis/GA/rot_ang/100.00'] = {'max2': -57.614673219663359, 'min1': 220.1740976900748, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GA/rot_ang/95.00'] = {'max2': -79.092575623790879, 'min1': 249.07378233193705, 'min2': -90.0, 'max1': 270.0} # lost: 13
limits['HW_cis/GA/rot_ang/99.00'] = {'max2': -67.225451389453724, 'min1': 245.96675324196354, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HW_cis/GA/rot_ang/99.50'] = {'max2': -67.225451389453724, 'min1': 220.1740976900748, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/GA/rot_ang/99.90'] = {'max2': -57.614673219663359, 'min1': 220.1740976900748, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GA/rot_ang/99.99'] = {'max2': -57.614673219663359, 'min1': 220.1740976900748, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GC/dist/100.00'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['HW_cis/GC/dist/95.00'] = {'max': 7.1335077739679136, 'min': 6.1596284055793866} # lost: 7
limits['HW_cis/GC/dist/99.00'] = {'max': 7.5498630103597213, 'min': 5.8695884481687735} # lost: 1
limits['HW_cis/GC/dist/99.50'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['HW_cis/GC/dist/99.90'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['HW_cis/GC/dist/99.99'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['HW_cis/GC/min_dist/100.00'] = {'max': 2.8681686380467051, 'min': 1.2926338642182127} # lost: 0
limits['HW_cis/GC/min_dist/95.00'] = {'max': 2.7437574286682764, 'min': 1.4285893596198409} # lost: 7
limits['HW_cis/GC/min_dist/99.00'] = {'max': 2.861819749632696, 'min': 1.2926338642182127} # lost: 1
limits['HW_cis/GC/min_dist/99.50'] = {'max': 2.8681686380467051, 'min': 1.2926338642182127} # lost: 0
limits['HW_cis/GC/min_dist/99.90'] = {'max': 2.8681686380467051, 'min': 1.2926338642182127} # lost: 0
limits['HW_cis/GC/min_dist/99.99'] = {'max': 2.8681686380467051, 'min': 1.2926338642182127} # lost: 0
limits['HW_cis/GC/n2_z/100.00'] = {'max': 0.99995488, 'min': 0.47034344} # lost: 0
limits['HW_cis/GC/n2_z/95.00'] = {'max': 0.99995488, 'min': 0.72257} # lost: 7
limits['HW_cis/GC/n2_z/99.00'] = {'max': 0.99995488, 'min': 0.48510757} # lost: 1
limits['HW_cis/GC/n2_z/99.50'] = {'max': 0.99995488, 'min': 0.47034344} # lost: 0
limits['HW_cis/GC/n2_z/99.90'] = {'max': 0.99995488, 'min': 0.47034344} # lost: 0
limits['HW_cis/GC/n2_z/99.99'] = {'max': 0.99995488, 'min': 0.47034344} # lost: 0
limits['HW_cis/GC/nn_ang_norm/100.00'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['HW_cis/GC/nn_ang_norm/95.00'] = {'max': 44.060949279105294, 'min': 0.91042718393079358} # lost: 7
limits['HW_cis/GC/nn_ang_norm/99.00'] = {'max': 60.724042702808482, 'min': 0.91042718393079358} # lost: 1
limits['HW_cis/GC/nn_ang_norm/99.50'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['HW_cis/GC/nn_ang_norm/99.90'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['HW_cis/GC/nn_ang_norm/99.99'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['HW_cis/GC/rot_ang/100.00'] = {'max2': -57.551927343314617, 'min1': 248.83763633141257, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GC/rot_ang/95.00'] = {'max2': -64.513982852486151, 'min1': 255.98423174308328, 'min2': -90.0, 'max1': 270.0} # lost: 7
limits['HW_cis/GC/rot_ang/99.00'] = {'max2': -59.814645122880563, 'min1': 248.83763633141257, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/GC/rot_ang/99.50'] = {'max2': -57.551927343314617, 'min1': 248.83763633141257, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GC/rot_ang/99.90'] = {'max2': -57.551927343314617, 'min1': 248.83763633141257, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GC/rot_ang/99.99'] = {'max2': -57.551927343314617, 'min1': 248.83763633141257, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GG/dist/100.00'] = {'max': 7.7887620907861619, 'min': 5.1958287289375411} # lost: 0
limits['HW_cis/GG/dist/95.00'] = {'max': 7.1521793541995633, 'min': 6.0931454015822872} # lost: 108
limits['HW_cis/GG/dist/99.00'] = {'max': 7.3377793372429814, 'min': 5.7580097678428022} # lost: 21
limits['HW_cis/GG/dist/99.50'] = {'max': 7.4402603918843369, 'min': 5.5568796168623686} # lost: 10
limits['HW_cis/GG/dist/99.90'] = {'max': 7.4610383035067356, 'min': 5.2427240427883914} # lost: 2
limits['HW_cis/GG/dist/99.99'] = {'max': 7.7887620907861619, 'min': 5.1958287289375411} # lost: 0
limits['HW_cis/GG/min_dist/100.00'] = {'max': 2.6176439087879513, 'min': 0.99980585755676987} # lost: 0
limits['HW_cis/GG/min_dist/95.00'] = {'max': 2.3522400709025706, 'min': 1.523150009627166} # lost: 108
limits['HW_cis/GG/min_dist/99.00'] = {'max': 2.5322986174806199, 'min': 1.3835028358603816} # lost: 21
limits['HW_cis/GG/min_dist/99.50'] = {'max': 2.5431111030351219, 'min': 1.3617136968669961} # lost: 10
limits['HW_cis/GG/min_dist/99.90'] = {'max': 2.5956585186380075, 'min': 1.2192218823563121} # lost: 2
limits['HW_cis/GG/min_dist/99.99'] = {'max': 2.6176439087879513, 'min': 0.99980585755676987} # lost: 0
limits['HW_cis/GG/n2_z/100.00'] = {'max': 0.99995041, 'min': 0.43970245} # lost: 0
limits['HW_cis/GG/n2_z/95.00'] = {'max': 0.99995041, 'min': 0.80479652} # lost: 108
limits['HW_cis/GG/n2_z/99.00'] = {'max': 0.99995041, 'min': 0.5998494} # lost: 21
limits['HW_cis/GG/n2_z/99.50'] = {'max': 0.99995041, 'min': 0.57031852} # lost: 10
limits['HW_cis/GG/n2_z/99.90'] = {'max': 0.99995041, 'min': 0.50080639} # lost: 2
limits['HW_cis/GG/n2_z/99.99'] = {'max': 0.99995041, 'min': 0.43970245} # lost: 0
limits['HW_cis/GG/nn_ang_norm/100.00'] = {'max': 63.894015458881441, 'min': 0.520769800980032} # lost: 0
limits['HW_cis/GG/nn_ang_norm/95.00'] = {'max': 36.927100143877531, 'min': 0.520769800980032} # lost: 108
limits['HW_cis/GG/nn_ang_norm/99.00'] = {'max': 53.514979524440541, 'min': 0.520769800980032} # lost: 21
limits['HW_cis/GG/nn_ang_norm/99.50'] = {'max': 56.58993751896945, 'min': 0.520769800980032} # lost: 10
limits['HW_cis/GG/nn_ang_norm/99.90'] = {'max': 60.867968448998994, 'min': 0.520769800980032} # lost: 2
limits['HW_cis/GG/nn_ang_norm/99.99'] = {'max': 63.894015458881441, 'min': 0.520769800980032} # lost: 0
limits['HW_cis/GG/rot_ang/100.00'] = {'max2': -57.311361399927478, 'min1': 230.84378611519253, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GG/rot_ang/95.00'] = {'max2': -72.971344570180349, 'min1': 255.8832816117731, 'min2': -90.0, 'max1': 270.0} # lost: 108
limits['HW_cis/GG/rot_ang/99.00'] = {'max2': -65.821907133261107, 'min1': 244.55896971622391, 'min2': -90.0, 'max1': 270.0} # lost: 21
limits['HW_cis/GG/rot_ang/99.50'] = {'max2': -61.530373020119271, 'min1': 242.18170963267653, 'min2': -90.0, 'max1': 270.0} # lost: 10
limits['HW_cis/GG/rot_ang/99.90'] = {'max2': -57.528843313496623, 'min1': 233.69879461727811, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HW_cis/GG/rot_ang/99.99'] = {'max2': -57.311361399927478, 'min1': 230.84378611519253, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GU/dist/100.00'] = {'max': 7.3880871083648554, 'min': 6.0860194029130028} # lost: 0
limits['HW_cis/GU/dist/95.00'] = {'max': 7.2698583239979344, 'min': 6.5193565590018832} # lost: 20
limits['HW_cis/GU/dist/99.00'] = {'max': 7.365575790798979, 'min': 6.1918362044458535} # lost: 4
limits['HW_cis/GU/dist/99.50'] = {'max': 7.387135491006859, 'min': 6.1302055310972712} # lost: 2
limits['HW_cis/GU/dist/99.90'] = {'max': 7.3880871083648554, 'min': 6.0860194029130028} # lost: 0
limits['HW_cis/GU/dist/99.99'] = {'max': 7.3880871083648554, 'min': 6.0860194029130028} # lost: 0
limits['HW_cis/GU/min_dist/100.00'] = {'max': 2.5489945599258861, 'min': 1.3353697699338309} # lost: 0
limits['HW_cis/GU/min_dist/95.00'] = {'max': 2.3904570638658238, 'min': 1.6996035052024028} # lost: 20
limits['HW_cis/GU/min_dist/99.00'] = {'max': 2.4828990688174239, 'min': 1.4229746533228145} # lost: 4
limits['HW_cis/GU/min_dist/99.50'] = {'max': 2.5153409417259187, 'min': 1.3568738769372146} # lost: 2
limits['HW_cis/GU/min_dist/99.90'] = {'max': 2.5489945599258861, 'min': 1.3353697699338309} # lost: 0
limits['HW_cis/GU/min_dist/99.99'] = {'max': 2.5489945599258861, 'min': 1.3353697699338309} # lost: 0
limits['HW_cis/GU/n2_z/100.00'] = {'max': 0.99556708, 'min': 0.51331085} # lost: 0
limits['HW_cis/GU/n2_z/95.00'] = {'max': 0.99556708, 'min': 0.86243379} # lost: 20
limits['HW_cis/GU/n2_z/99.00'] = {'max': 0.99556708, 'min': 0.78934634} # lost: 4
limits['HW_cis/GU/n2_z/99.50'] = {'max': 0.99556708, 'min': 0.77245176} # lost: 2
limits['HW_cis/GU/n2_z/99.90'] = {'max': 0.99556708, 'min': 0.51331085} # lost: 0
limits['HW_cis/GU/n2_z/99.99'] = {'max': 0.99556708, 'min': 0.51331085} # lost: 0
limits['HW_cis/GU/nn_ang_norm/100.00'] = {'max': 59.246208332471163, 'min': 5.2920946019493487} # lost: 0
limits['HW_cis/GU/nn_ang_norm/95.00'] = {'max': 30.671039600023128, 'min': 5.2920946019493487} # lost: 20
limits['HW_cis/GU/nn_ang_norm/99.00'] = {'max': 39.357865431742105, 'min': 5.2920946019493487} # lost: 4
limits['HW_cis/GU/nn_ang_norm/99.50'] = {'max': 43.723688198268405, 'min': 5.2920946019493487} # lost: 2
limits['HW_cis/GU/nn_ang_norm/99.90'] = {'max': 59.246208332471163, 'min': 5.2920946019493487} # lost: 0
limits['HW_cis/GU/nn_ang_norm/99.99'] = {'max': 59.246208332471163, 'min': 5.2920946019493487} # lost: 0
limits['HW_cis/GU/rot_ang/100.00'] = {'max2': -39.312938515248788, 'min1': 262.06303077115098, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GU/rot_ang/95.00'] = {'max2': -45.138764895922066, 'min1': 294.28090815643276, 'min2': -90.0, 'max1': 270.0} # lost: 20
limits['HW_cis/GU/rot_ang/99.00'] = {'max2': -42.848771684063252, 'min1': 275.11342382644494, 'min2': -90.0, 'max1': 270.0} # lost: 4
limits['HW_cis/GU/rot_ang/99.50'] = {'max2': -40.545855185382095, 'min1': 272.3585019814318, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['HW_cis/GU/rot_ang/99.90'] = {'max2': -39.312938515248788, 'min1': 262.06303077115098, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/GU/rot_ang/99.99'] = {'max2': -39.312938515248788, 'min1': 262.06303077115098, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UA/dist/100.00'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['HW_cis/UA/dist/95.00'] = {'max': 6.7490226497756227, 'min': 4.8157469719130379} # lost: 1
limits['HW_cis/UA/dist/99.00'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['HW_cis/UA/dist/99.50'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['HW_cis/UA/dist/99.90'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['HW_cis/UA/dist/99.99'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['HW_cis/UA/min_dist/100.00'] = {'max': 2.3931152011592509, 'min': 1.2876691192092744} # lost: 0
limits['HW_cis/UA/min_dist/95.00'] = {'max': 2.3644425506085973, 'min': 1.2876691192092744} # lost: 1
limits['HW_cis/UA/min_dist/99.00'] = {'max': 2.3931152011592509, 'min': 1.2876691192092744} # lost: 0
limits['HW_cis/UA/min_dist/99.50'] = {'max': 2.3931152011592509, 'min': 1.2876691192092744} # lost: 0
limits['HW_cis/UA/min_dist/99.90'] = {'max': 2.3931152011592509, 'min': 1.2876691192092744} # lost: 0
limits['HW_cis/UA/min_dist/99.99'] = {'max': 2.3931152011592509, 'min': 1.2876691192092744} # lost: 0
limits['HW_cis/UA/n2_z/100.00'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['HW_cis/UA/n2_z/95.00'] = {'max': 0.99137288, 'min': 0.61221051} # lost: 1
limits['HW_cis/UA/n2_z/99.00'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['HW_cis/UA/n2_z/99.50'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['HW_cis/UA/n2_z/99.90'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['HW_cis/UA/n2_z/99.99'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['HW_cis/UA/nn_ang_norm/100.00'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['HW_cis/UA/nn_ang_norm/95.00'] = {'max': 52.068123477083816, 'min': 8.8426019561194575} # lost: 1
limits['HW_cis/UA/nn_ang_norm/99.00'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['HW_cis/UA/nn_ang_norm/99.50'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['HW_cis/UA/nn_ang_norm/99.90'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['HW_cis/UA/nn_ang_norm/99.99'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['HW_cis/UA/rot_ang/100.00'] = {'max2': -60.01146769113052, 'min1': 216.66451767755981, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UA/rot_ang/95.00'] = {'max2': -60.013187900301148, 'min1': 216.66451767755981, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/UA/rot_ang/99.00'] = {'max2': -60.01146769113052, 'min1': 216.66451767755981, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UA/rot_ang/99.50'] = {'max2': -60.01146769113052, 'min1': 216.66451767755981, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UA/rot_ang/99.90'] = {'max2': -60.01146769113052, 'min1': 216.66451767755981, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UA/rot_ang/99.99'] = {'max2': -60.01146769113052, 'min1': 216.66451767755981, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UC/dist/100.00'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['HW_cis/UC/dist/95.00'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['HW_cis/UC/dist/99.00'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['HW_cis/UC/dist/99.50'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['HW_cis/UC/dist/99.90'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['HW_cis/UC/dist/99.99'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['HW_cis/UC/min_dist/100.00'] = {'max': 1.7397570371970823, 'min': 1.7395906209843577} # lost: 0
limits['HW_cis/UC/min_dist/95.00'] = {'max': 1.7397570371970823, 'min': 1.7395906209843577} # lost: 0
limits['HW_cis/UC/min_dist/99.00'] = {'max': 1.7397570371970823, 'min': 1.7395906209843577} # lost: 0
limits['HW_cis/UC/min_dist/99.50'] = {'max': 1.7397570371970823, 'min': 1.7395906209843577} # lost: 0
limits['HW_cis/UC/min_dist/99.90'] = {'max': 1.7397570371970823, 'min': 1.7395906209843577} # lost: 0
limits['HW_cis/UC/min_dist/99.99'] = {'max': 1.7397570371970823, 'min': 1.7395906209843577} # lost: 0
limits['HW_cis/UC/n2_z/100.00'] = {'max': 0.98431253, 'min': 0.98261851} # lost: 0
limits['HW_cis/UC/n2_z/95.00'] = {'max': 0.98431253, 'min': 0.98261851} # lost: 0
limits['HW_cis/UC/n2_z/99.00'] = {'max': 0.98431253, 'min': 0.98261851} # lost: 0
limits['HW_cis/UC/n2_z/99.50'] = {'max': 0.98431253, 'min': 0.98261851} # lost: 0
limits['HW_cis/UC/n2_z/99.90'] = {'max': 0.98431253, 'min': 0.98261851} # lost: 0
limits['HW_cis/UC/n2_z/99.99'] = {'max': 0.98431253, 'min': 0.98261851} # lost: 0
limits['HW_cis/UC/nn_ang_norm/100.00'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['HW_cis/UC/nn_ang_norm/95.00'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['HW_cis/UC/nn_ang_norm/99.00'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['HW_cis/UC/nn_ang_norm/99.50'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['HW_cis/UC/nn_ang_norm/99.90'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['HW_cis/UC/nn_ang_norm/99.99'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['HW_cis/UC/rot_ang/100.00'] = {'max': -87.208992900754637, 'min': -87.315316578653167} # lost: 0
limits['HW_cis/UC/rot_ang/95.00'] = {'max': -87.208992900754637, 'min': -87.315316578653167} # lost: 0
limits['HW_cis/UC/rot_ang/99.00'] = {'max': -87.208992900754637, 'min': -87.315316578653167} # lost: 0
limits['HW_cis/UC/rot_ang/99.50'] = {'max': -87.208992900754637, 'min': -87.315316578653167} # lost: 0
limits['HW_cis/UC/rot_ang/99.90'] = {'max': -87.208992900754637, 'min': -87.315316578653167} # lost: 0
limits['HW_cis/UC/rot_ang/99.99'] = {'max': -87.208992900754637, 'min': -87.315316578653167} # lost: 0
limits['HW_cis/UG/dist/100.00'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['HW_cis/UG/dist/95.00'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['HW_cis/UG/dist/99.00'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['HW_cis/UG/dist/99.50'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['HW_cis/UG/dist/99.90'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['HW_cis/UG/dist/99.99'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['HW_cis/UG/min_dist/100.00'] = {'max': 2.0506865107889314, 'min': 1.2747842666428446} # lost: 0
limits['HW_cis/UG/min_dist/95.00'] = {'max': 2.0506865107889314, 'min': 1.2747842666428446} # lost: 0
limits['HW_cis/UG/min_dist/99.00'] = {'max': 2.0506865107889314, 'min': 1.2747842666428446} # lost: 0
limits['HW_cis/UG/min_dist/99.50'] = {'max': 2.0506865107889314, 'min': 1.2747842666428446} # lost: 0
limits['HW_cis/UG/min_dist/99.90'] = {'max': 2.0506865107889314, 'min': 1.2747842666428446} # lost: 0
limits['HW_cis/UG/min_dist/99.99'] = {'max': 2.0506865107889314, 'min': 1.2747842666428446} # lost: 0
limits['HW_cis/UG/n2_z/100.00'] = {'max': 0.9995811, 'min': 0.75022316} # lost: 0
limits['HW_cis/UG/n2_z/95.00'] = {'max': 0.9995811, 'min': 0.75022316} # lost: 0
limits['HW_cis/UG/n2_z/99.00'] = {'max': 0.9995811, 'min': 0.75022316} # lost: 0
limits['HW_cis/UG/n2_z/99.50'] = {'max': 0.9995811, 'min': 0.75022316} # lost: 0
limits['HW_cis/UG/n2_z/99.90'] = {'max': 0.9995811, 'min': 0.75022316} # lost: 0
limits['HW_cis/UG/n2_z/99.99'] = {'max': 0.9995811, 'min': 0.75022316} # lost: 0
limits['HW_cis/UG/nn_ang_norm/100.00'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['HW_cis/UG/nn_ang_norm/95.00'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['HW_cis/UG/nn_ang_norm/99.00'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['HW_cis/UG/nn_ang_norm/99.50'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['HW_cis/UG/nn_ang_norm/99.90'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['HW_cis/UG/nn_ang_norm/99.99'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['HW_cis/UG/rot_ang/100.00'] = {'max2': -83.621093739564344, 'min1': 252.95811867622893, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UG/rot_ang/95.00'] = {'max2': -83.621093739564344, 'min1': 252.95811867622893, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UG/rot_ang/99.00'] = {'max2': -83.621093739564344, 'min1': 252.95811867622893, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UG/rot_ang/99.50'] = {'max2': -83.621093739564344, 'min1': 252.95811867622893, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UG/rot_ang/99.90'] = {'max2': -83.621093739564344, 'min1': 252.95811867622893, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UG/rot_ang/99.99'] = {'max2': -83.621093739564344, 'min1': 252.95811867622893, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UU/dist/100.00'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['HW_cis/UU/dist/95.00'] = {'max': 6.6587006008187899, 'min': 5.7598582239808911} # lost: 8
limits['HW_cis/UU/dist/99.00'] = {'max': 6.6919297687506809, 'min': 5.6287038760508166} # lost: 1
limits['HW_cis/UU/dist/99.50'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['HW_cis/UU/dist/99.90'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['HW_cis/UU/dist/99.99'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['HW_cis/UU/min_dist/100.00'] = {'max': 2.4168464566149028, 'min': 1.2723874945094666} # lost: 0
limits['HW_cis/UU/min_dist/95.00'] = {'max': 2.3207858058459832, 'min': 1.3959780728434101} # lost: 8
limits['HW_cis/UU/min_dist/99.00'] = {'max': 2.3910081108767587, 'min': 1.2723874945094666} # lost: 1
limits['HW_cis/UU/min_dist/99.50'] = {'max': 2.4168464566149028, 'min': 1.2723874945094666} # lost: 0
limits['HW_cis/UU/min_dist/99.90'] = {'max': 2.4168464566149028, 'min': 1.2723874945094666} # lost: 0
limits['HW_cis/UU/min_dist/99.99'] = {'max': 2.4168464566149028, 'min': 1.2723874945094666} # lost: 0
limits['HW_cis/UU/n2_z/100.00'] = {'max': 0.99916577, 'min': 0.44642642} # lost: 0
limits['HW_cis/UU/n2_z/95.00'] = {'max': 0.99916577, 'min': 0.57559872} # lost: 8
limits['HW_cis/UU/n2_z/99.00'] = {'max': 0.99916577, 'min': 0.48885497} # lost: 1
limits['HW_cis/UU/n2_z/99.50'] = {'max': 0.99916577, 'min': 0.44642642} # lost: 0
limits['HW_cis/UU/n2_z/99.90'] = {'max': 0.99916577, 'min': 0.44642642} # lost: 0
limits['HW_cis/UU/n2_z/99.99'] = {'max': 0.99916577, 'min': 0.44642642} # lost: 0
limits['HW_cis/UU/nn_ang_norm/100.00'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['HW_cis/UU/nn_ang_norm/95.00'] = {'max': 54.002094955667509, 'min': 2.584977298945121} # lost: 8
limits['HW_cis/UU/nn_ang_norm/99.00'] = {'max': 61.246162853531764, 'min': 2.584977298945121} # lost: 1
limits['HW_cis/UU/nn_ang_norm/99.50'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['HW_cis/UU/nn_ang_norm/99.90'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['HW_cis/UU/nn_ang_norm/99.99'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['HW_cis/UU/rot_ang/100.00'] = {'max2': -60.219312118810649, 'min1': 258.52563767135354, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UU/rot_ang/95.00'] = {'max2': -64.934231252034238, 'min1': 268.66596062091526, 'min2': -90.0, 'max1': 270.0} # lost: 8
limits['HW_cis/UU/rot_ang/99.00'] = {'max2': -61.791101805683695, 'min1': 258.52563767135354, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['HW_cis/UU/rot_ang/99.50'] = {'max2': -60.219312118810649, 'min1': 258.52563767135354, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UU/rot_ang/99.90'] = {'max2': -60.219312118810649, 'min1': 258.52563767135354, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_cis/UU/rot_ang/99.99'] = {'max2': -60.219312118810649, 'min1': 258.52563767135354, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['HW_tran/AA/dist/100.00'] = {'max': 7.8785453776359304, 'min': 5.1196107108970264} # lost: 0
limits['HW_tran/AA/dist/95.00'] = {'max': 6.9927163981090237, 'min': 6.1555064191276037} # lost: 141
limits['HW_tran/AA/dist/99.00'] = {'max': 7.1842942975069892, 'min': 6.0091582151294354} # lost: 28
limits['HW_tran/AA/dist/99.50'] = {'max': 7.3768559234975575, 'min': 5.8557940292528698} # lost: 14
limits['HW_tran/AA/dist/99.90'] = {'max': 7.6583550464692056, 'min': 5.2636752184535132} # lost: 2
limits['HW_tran/AA/dist/99.99'] = {'max': 7.8785453776359304, 'min': 5.1196107108970264} # lost: 0
limits['HW_tran/AA/min_dist/100.00'] = {'max': 2.8576138984200248, 'min': 1.3541469018566801} # lost: 0
limits['HW_tran/AA/min_dist/95.00'] = {'max': 2.4267636105599704, 'min': 1.6591148891149172} # lost: 141
limits['HW_tran/AA/min_dist/99.00'] = {'max': 2.5396243486584837, 'min': 1.4976836677458008} # lost: 28
limits['HW_tran/AA/min_dist/99.50'] = {'max': 2.5858835804933911, 'min': 1.4296681645693101} # lost: 14
limits['HW_tran/AA/min_dist/99.90'] = {'max': 2.7475437717291951, 'min': 1.3551539029068649} # lost: 2
limits['HW_tran/AA/min_dist/99.99'] = {'max': 2.8576138984200248, 'min': 1.3541469018566801} # lost: 0
limits['HW_tran/AA/n2_z/100.00'] = {'max': -0.43410671, 'min': -0.99992174} # lost: 0
limits['HW_tran/AA/n2_z/95.00'] = {'max': -0.66617978, 'min': -0.99992174} # lost: 141
limits['HW_tran/AA/n2_z/99.00'] = {'max': -0.52931845, 'min': -0.99992174} # lost: 28
limits['HW_tran/AA/n2_z/99.50'] = {'max': -0.49162456, 'min': -0.99992174} # lost: 14
limits['HW_tran/AA/n2_z/99.90'] = {'max': -0.44182387, 'min': -0.99992174} # lost: 2
limits['HW_tran/AA/n2_z/99.99'] = {'max': -0.43410671, 'min': -0.99992174} # lost: 0
limits['HW_tran/AA/nn_ang_norm/100.00'] = {'max': 64.04650125333481, 'min': 0.73675383643458758} # lost: 0
limits['HW_tran/AA/nn_ang_norm/95.00'] = {'max': 48.528516364740938, 'min': 0.73675383643458758} # lost: 141
limits['HW_tran/AA/nn_ang_norm/99.00'] = {'max': 57.918223303567586, 'min': 0.73675383643458758} # lost: 28
limits['HW_tran/AA/nn_ang_norm/99.50'] = {'max': 60.252508754311151, 'min': 0.73675383643458758} # lost: 14
limits['HW_tran/AA/nn_ang_norm/99.90'] = {'max': 63.728528626714038, 'min': 0.73675383643458758} # lost: 2
limits['HW_tran/AA/nn_ang_norm/99.99'] = {'max': 64.04650125333481, 'min': 0.73675383643458758} # lost: 0
limits['HW_tran/AA/rot_ang/100.00'] = {'max': 224.25025771075249, 'min': 148.33540054968321} # lost: 0
limits['HW_tran/AA/rot_ang/95.00'] = {'max': 191.98684964601074, 'min': 157.19802149152321} # lost: 141
limits['HW_tran/AA/rot_ang/99.00'] = {'max': 204.65561609206435, 'min': 152.73777173836697} # lost: 28
limits['HW_tran/AA/rot_ang/99.50'] = {'max': 213.35817122780139, 'min': 151.99998085409828} # lost: 14
limits['HW_tran/AA/rot_ang/99.90'] = {'max': 220.92110174252932, 'min': 149.02699658908645} # lost: 2
limits['HW_tran/AA/rot_ang/99.99'] = {'max': 224.25025771075249, 'min': 148.33540054968321} # lost: 0
limits['HW_tran/AC/dist/100.00'] = {'max': 7.8111440462867519, 'min': 5.8480414000075731} # lost: 0
limits['HW_tran/AC/dist/95.00'] = {'max': 7.0342974770898659, 'min': 6.1383287613702162} # lost: 177
limits['HW_tran/AC/dist/99.00'] = {'max': 7.4304944767110577, 'min': 5.9980521340405453} # lost: 35
limits['HW_tran/AC/dist/99.50'] = {'max': 7.5488389970410656, 'min': 5.9695790824428796} # lost: 17
limits['HW_tran/AC/dist/99.90'] = {'max': 7.7693849524145682, 'min': 5.8846615569512313} # lost: 3
limits['HW_tran/AC/dist/99.99'] = {'max': 7.8111440462867519, 'min': 5.8480414000075731} # lost: 0
limits['HW_tran/AC/min_dist/100.00'] = {'max': 2.8512445124601271, 'min': 1.0362727683322355} # lost: 0
limits['HW_tran/AC/min_dist/95.00'] = {'max': 2.4006954265265019, 'min': 1.6353663870398027} # lost: 177
limits['HW_tran/AC/min_dist/99.00'] = {'max': 2.5437194461416324, 'min': 1.3964742046922001} # lost: 35
limits['HW_tran/AC/min_dist/99.50'] = {'max': 2.5854758352313985, 'min': 1.2747569249915547} # lost: 17
limits['HW_tran/AC/min_dist/99.90'] = {'max': 2.809488031203232, 'min': 1.0532334938028809} # lost: 3
limits['HW_tran/AC/min_dist/99.99'] = {'max': 2.8512445124601271, 'min': 1.0362727683322355} # lost: 0
limits['HW_tran/AC/n2_z/100.00'] = {'max': -0.42282072, 'min': -0.99998987} # lost: 0
limits['HW_tran/AC/n2_z/95.00'] = {'max': -0.66503882, 'min': -0.99998987} # lost: 177
limits['HW_tran/AC/n2_z/99.00'] = {'max': -0.46866408, 'min': -0.99998987} # lost: 35
limits['HW_tran/AC/n2_z/99.50'] = {'max': -0.45061633, 'min': -0.99998987} # lost: 17
limits['HW_tran/AC/n2_z/99.90'] = {'max': -0.42938536, 'min': -0.99998987} # lost: 3
limits['HW_tran/AC/n2_z/99.99'] = {'max': -0.42282072, 'min': -0.99998987} # lost: 0
limits['HW_tran/AC/nn_ang_norm/100.00'] = {'max': 64.883786822929991, 'min': 0.17583138103648821} # lost: 0
limits['HW_tran/AC/nn_ang_norm/95.00'] = {'max': 48.182294075713003, 'min': 0.17583138103648821} # lost: 177
limits['HW_tran/AC/nn_ang_norm/99.00'] = {'max': 61.930372044681462, 'min': 0.17583138103648821} # lost: 35
limits['HW_tran/AC/nn_ang_norm/99.50'] = {'max': 63.275045046960216, 'min': 0.17583138103648821} # lost: 17
limits['HW_tran/AC/nn_ang_norm/99.90'] = {'max': 64.537810420712162, 'min': 0.17583138103648821} # lost: 3
limits['HW_tran/AC/nn_ang_norm/99.99'] = {'max': 64.883786822929991, 'min': 0.17583138103648821} # lost: 0
limits['HW_tran/AC/rot_ang/100.00'] = {'max': 214.85802162722212, 'min': 126.820835555144} # lost: 0
limits['HW_tran/AC/rot_ang/95.00'] = {'max': 178.5696440496655, 'min': 142.55628506686028} # lost: 177
limits['HW_tran/AC/rot_ang/99.00'] = {'max': 201.68632079076508, 'min': 137.24251398378527} # lost: 35
limits['HW_tran/AC/rot_ang/99.50'] = {'max': 208.24733734506438, 'min': 134.86217378021976} # lost: 17
limits['HW_tran/AC/rot_ang/99.90'] = {'max': 211.79209136965412, 'min': 129.07881757258951} # lost: 3
limits['HW_tran/AC/rot_ang/99.99'] = {'max': 214.85802162722212, 'min': 126.820835555144} # lost: 0
limits['HW_tran/AG/dist/100.00'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['HW_tran/AG/dist/95.00'] = {'max': 8.1390553818236189, 'min': 6.0153605887810571} # lost: 6
limits['HW_tran/AG/dist/99.00'] = {'max': 8.198340272320932, 'min': 5.459736786735025} # lost: 1
limits['HW_tran/AG/dist/99.50'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['HW_tran/AG/dist/99.90'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['HW_tran/AG/dist/99.99'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['HW_tran/AG/min_dist/100.00'] = {'max': 2.3858930974972372, 'min': 0.84746094334068967} # lost: 0
limits['HW_tran/AG/min_dist/95.00'] = {'max': 2.3458465116248801, 'min': 0.99564495183688384} # lost: 6
limits['HW_tran/AG/min_dist/99.00'] = {'max': 2.3642944006642574, 'min': 0.84746094334068967} # lost: 1
limits['HW_tran/AG/min_dist/99.50'] = {'max': 2.3858930974972372, 'min': 0.84746094334068967} # lost: 0
limits['HW_tran/AG/min_dist/99.90'] = {'max': 2.3858930974972372, 'min': 0.84746094334068967} # lost: 0
limits['HW_tran/AG/min_dist/99.99'] = {'max': 2.3858930974972372, 'min': 0.84746094334068967} # lost: 0
limits['HW_tran/AG/n2_z/100.00'] = {'max': -0.4800835, 'min': -0.9988268} # lost: 0
limits['HW_tran/AG/n2_z/95.00'] = {'max': -0.74822611, 'min': -0.9988268} # lost: 6
limits['HW_tran/AG/n2_z/99.00'] = {'max': -0.59034383, 'min': -0.9988268} # lost: 1
limits['HW_tran/AG/n2_z/99.50'] = {'max': -0.4800835, 'min': -0.9988268} # lost: 0
limits['HW_tran/AG/n2_z/99.90'] = {'max': -0.4800835, 'min': -0.9988268} # lost: 0
limits['HW_tran/AG/n2_z/99.99'] = {'max': -0.4800835, 'min': -0.9988268} # lost: 0
limits['HW_tran/AG/nn_ang_norm/100.00'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['HW_tran/AG/nn_ang_norm/95.00'] = {'max': 41.701346138341336, 'min': 2.9914675833475144} # lost: 6
limits['HW_tran/AG/nn_ang_norm/99.00'] = {'max': 53.843783237223207, 'min': 2.9914675833475144} # lost: 1
limits['HW_tran/AG/nn_ang_norm/99.50'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['HW_tran/AG/nn_ang_norm/99.90'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['HW_tran/AG/nn_ang_norm/99.99'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['HW_tran/AG/rot_ang/100.00'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['HW_tran/AG/rot_ang/95.00'] = {'max': 201.28629099718589, 'min': 126.44908207696861} # lost: 6
limits['HW_tran/AG/rot_ang/99.00'] = {'max': 207.61404296689827, 'min': 104.46383412471042} # lost: 1
limits['HW_tran/AG/rot_ang/99.50'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['HW_tran/AG/rot_ang/99.90'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['HW_tran/AG/rot_ang/99.99'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['HW_tran/AU/dist/100.00'] = {'max': 7.5791695769343397, 'min': 5.3784864080613959} # lost: 0
limits['HW_tran/AU/dist/95.00'] = {'max': 7.0136329407869864, 'min': 6.1516119274546019} # lost: 744
limits['HW_tran/AU/dist/99.00'] = {'max': 7.255761533270932, 'min': 5.9745780530802417} # lost: 148
limits['HW_tran/AU/dist/99.50'] = {'max': 7.368886096933716, 'min': 5.9072392905607174} # lost: 74
limits['HW_tran/AU/dist/99.90'] = {'max': 7.4908629422789463, 'min': 5.7858036205310466} # lost: 14
limits['HW_tran/AU/dist/99.99'] = {'max': 7.5753404331476837, 'min': 5.3784864080613959} # lost: 1
limits['HW_tran/AU/min_dist/100.00'] = {'max': 2.7961153733768742, 'min': 0.65013165933493011} # lost: 0
limits['HW_tran/AU/min_dist/95.00'] = {'max': 2.3078384663039042, 'min': 1.5045092057778984} # lost: 744
limits['HW_tran/AU/min_dist/99.00'] = {'max': 2.4851987937805036, 'min': 1.2696740161388966} # lost: 148
limits['HW_tran/AU/min_dist/99.50'] = {'max': 2.5380292607177877, 'min': 1.164876236774832} # lost: 74
limits['HW_tran/AU/min_dist/99.90'] = {'max': 2.6608973350598784, 'min': 0.94951782182938038} # lost: 14
limits['HW_tran/AU/min_dist/99.99'] = {'max': 2.7924068481211637, 'min': 0.65013165933493011} # lost: 1
limits['HW_tran/AU/n2_z/100.00'] = {'max': -0.42248958, 'min': -0.9999994} # lost: 0
limits['HW_tran/AU/n2_z/95.00'] = {'max': -0.80135244, 'min': -0.9999994} # lost: 744
limits['HW_tran/AU/n2_z/99.00'] = {'max': -0.59974891, 'min': -0.9999994} # lost: 148
limits['HW_tran/AU/n2_z/99.50'] = {'max': -0.5442214, 'min': -0.9999994} # lost: 74
limits['HW_tran/AU/n2_z/99.90'] = {'max': -0.46283144, 'min': -0.9999994} # lost: 14
limits['HW_tran/AU/n2_z/99.99'] = {'max': -0.42815989, 'min': -0.9999994} # lost: 1
limits['HW_tran/AU/nn_ang_norm/100.00'] = {'max': 64.974191206784283, 'min': 0.044240956487016092} # lost: 0
limits['HW_tran/AU/nn_ang_norm/95.00'] = {'max': 36.700500194111441, 'min': 0.044240956487016092} # lost: 744
limits['HW_tran/AU/nn_ang_norm/99.00'] = {'max': 53.015131026738914, 'min': 0.044240956487016092} # lost: 148
limits['HW_tran/AU/nn_ang_norm/99.50'] = {'max': 57.114514943932193, 'min': 0.044240956487016092} # lost: 74
limits['HW_tran/AU/nn_ang_norm/99.90'] = {'max': 62.447622270526523, 'min': 0.044240956487016092} # lost: 14
limits['HW_tran/AU/nn_ang_norm/99.99'] = {'max': 64.346578784330148, 'min': 0.044240956487016092} # lost: 1
limits['HW_tran/AU/rot_ang/100.00'] = {'max': 209.22466754589814, 'min': 127.65819618729412} # lost: 0
limits['HW_tran/AU/rot_ang/95.00'] = {'max': 181.85328338560683, 'min': 149.93992334333683} # lost: 744
limits['HW_tran/AU/rot_ang/99.00'] = {'max': 189.4844673968295, 'min': 142.66168402343195} # lost: 148
limits['HW_tran/AU/rot_ang/99.50'] = {'max': 192.72087195982235, 'min': 141.52364974803285} # lost: 74
limits['HW_tran/AU/rot_ang/99.90'] = {'max': 197.80785795310652, 'min': 134.09886431618077} # lost: 14
limits['HW_tran/AU/rot_ang/99.99'] = {'max': 202.69379069489963, 'min': 127.65819618729412} # lost: 1
limits['HW_tran/CA/dist/100.00'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['HW_tran/CA/dist/95.00'] = {'max': 6.579387341090011, 'min': 5.0984077003669821} # lost: 3
limits['HW_tran/CA/dist/99.00'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['HW_tran/CA/dist/99.50'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['HW_tran/CA/dist/99.90'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['HW_tran/CA/dist/99.99'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['HW_tran/CA/min_dist/100.00'] = {'max': 2.3621323950687469, 'min': 0.89439678569047887} # lost: 0
limits['HW_tran/CA/min_dist/95.00'] = {'max': 2.2437846811135858, 'min': 0.89449378036260019} # lost: 3
limits['HW_tran/CA/min_dist/99.00'] = {'max': 2.3621323950687469, 'min': 0.89439678569047887} # lost: 0
limits['HW_tran/CA/min_dist/99.50'] = {'max': 2.3621323950687469, 'min': 0.89439678569047887} # lost: 0
limits['HW_tran/CA/min_dist/99.90'] = {'max': 2.3621323950687469, 'min': 0.89439678569047887} # lost: 0
limits['HW_tran/CA/min_dist/99.99'] = {'max': 2.3621323950687469, 'min': 0.89439678569047887} # lost: 0
limits['HW_tran/CA/n2_z/100.00'] = {'max': -0.4999119, 'min': -0.99384981} # lost: 0
limits['HW_tran/CA/n2_z/95.00'] = {'max': -0.60165495, 'min': -0.99384981} # lost: 3
limits['HW_tran/CA/n2_z/99.00'] = {'max': -0.4999119, 'min': -0.99384981} # lost: 0
limits['HW_tran/CA/n2_z/99.50'] = {'max': -0.4999119, 'min': -0.99384981} # lost: 0
limits['HW_tran/CA/n2_z/99.90'] = {'max': -0.4999119, 'min': -0.99384981} # lost: 0
limits['HW_tran/CA/n2_z/99.99'] = {'max': -0.4999119, 'min': -0.99384981} # lost: 0
limits['HW_tran/CA/nn_ang_norm/100.00'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['HW_tran/CA/nn_ang_norm/95.00'] = {'max': 53.592664502198517, 'min': 6.4181734899429159} # lost: 3
limits['HW_tran/CA/nn_ang_norm/99.00'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['HW_tran/CA/nn_ang_norm/99.50'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['HW_tran/CA/nn_ang_norm/99.90'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['HW_tran/CA/nn_ang_norm/99.99'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['HW_tran/CA/rot_ang/100.00'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['HW_tran/CA/rot_ang/95.00'] = {'max': 176.46594243209574, 'min': 136.54476186111572} # lost: 3
limits['HW_tran/CA/rot_ang/99.00'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['HW_tran/CA/rot_ang/99.50'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['HW_tran/CA/rot_ang/99.90'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['HW_tran/CA/rot_ang/99.99'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['HW_tran/CC/dist/100.00'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['HW_tran/CC/dist/95.00'] = {'max': 6.6121571596957898, 'min': 5.603628439139726} # lost: 6
limits['HW_tran/CC/dist/99.00'] = {'max': 6.8752416381481787, 'min': 5.001801140108693} # lost: 1
limits['HW_tran/CC/dist/99.50'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['HW_tran/CC/dist/99.90'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['HW_tran/CC/dist/99.99'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['HW_tran/CC/min_dist/100.00'] = {'max': 2.6923410521513818, 'min': 1.3683515627100997} # lost: 0
limits['HW_tran/CC/min_dist/95.00'] = {'max': 2.4872436465117289, 'min': 1.5521634949466714} # lost: 6
limits['HW_tran/CC/min_dist/99.00'] = {'max': 2.5621258483203047, 'min': 1.3683515627100997} # lost: 1
limits['HW_tran/CC/min_dist/99.50'] = {'max': 2.6923410521513818, 'min': 1.3683515627100997} # lost: 0
limits['HW_tran/CC/min_dist/99.90'] = {'max': 2.6923410521513818, 'min': 1.3683515627100997} # lost: 0
limits['HW_tran/CC/min_dist/99.99'] = {'max': 2.6923410521513818, 'min': 1.3683515627100997} # lost: 0
limits['HW_tran/CC/n2_z/100.00'] = {'max': -0.45343342, 'min': -0.99785686} # lost: 0
limits['HW_tran/CC/n2_z/95.00'] = {'max': -0.82083666, 'min': -0.99785686} # lost: 6
limits['HW_tran/CC/n2_z/99.00'] = {'max': -0.71166962, 'min': -0.99785686} # lost: 1
limits['HW_tran/CC/n2_z/99.50'] = {'max': -0.45343342, 'min': -0.99785686} # lost: 0
limits['HW_tran/CC/n2_z/99.90'] = {'max': -0.45343342, 'min': -0.99785686} # lost: 0
limits['HW_tran/CC/n2_z/99.99'] = {'max': -0.45343342, 'min': -0.99785686} # lost: 0
limits['HW_tran/CC/nn_ang_norm/100.00'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['HW_tran/CC/nn_ang_norm/95.00'] = {'max': 34.782692358198574, 'min': 2.180683147731969} # lost: 6
limits['HW_tran/CC/nn_ang_norm/99.00'] = {'max': 45.242730921101241, 'min': 2.180683147731969} # lost: 1
limits['HW_tran/CC/nn_ang_norm/99.50'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['HW_tran/CC/nn_ang_norm/99.90'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['HW_tran/CC/nn_ang_norm/99.99'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['HW_tran/CC/rot_ang/100.00'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['HW_tran/CC/rot_ang/95.00'] = {'max': 172.89913328603151, 'min': 130.59661166412661} # lost: 6
limits['HW_tran/CC/rot_ang/99.00'] = {'max': 182.04381121834876, 'min': 125.04704174030724} # lost: 1
limits['HW_tran/CC/rot_ang/99.50'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['HW_tran/CC/rot_ang/99.90'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['HW_tran/CC/rot_ang/99.99'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['HW_tran/CG/dist/100.00'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['HW_tran/CG/dist/95.00'] = {'max': 7.3451477984825519, 'min': 5.4965649412574979} # lost: 2
limits['HW_tran/CG/dist/99.00'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['HW_tran/CG/dist/99.50'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['HW_tran/CG/dist/99.90'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['HW_tran/CG/dist/99.99'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['HW_tran/CG/min_dist/100.00'] = {'max': 2.1573701748014646, 'min': 0.73871294820265321} # lost: 0
limits['HW_tran/CG/min_dist/95.00'] = {'max': 2.0993804175392339, 'min': 0.75854556213729141} # lost: 2
limits['HW_tran/CG/min_dist/99.00'] = {'max': 2.1573701748014646, 'min': 0.73871294820265321} # lost: 0
limits['HW_tran/CG/min_dist/99.50'] = {'max': 2.1573701748014646, 'min': 0.73871294820265321} # lost: 0
limits['HW_tran/CG/min_dist/99.90'] = {'max': 2.1573701748014646, 'min': 0.73871294820265321} # lost: 0
limits['HW_tran/CG/min_dist/99.99'] = {'max': 2.1573701748014646, 'min': 0.73871294820265321} # lost: 0
limits['HW_tran/CG/n2_z/100.00'] = {'max': -0.50038558, 'min': -0.99402624} # lost: 0
limits['HW_tran/CG/n2_z/95.00'] = {'max': -0.63288546, 'min': -0.99402624} # lost: 2
limits['HW_tran/CG/n2_z/99.00'] = {'max': -0.50038558, 'min': -0.99402624} # lost: 0
limits['HW_tran/CG/n2_z/99.50'] = {'max': -0.50038558, 'min': -0.99402624} # lost: 0
limits['HW_tran/CG/n2_z/99.90'] = {'max': -0.50038558, 'min': -0.99402624} # lost: 0
limits['HW_tran/CG/n2_z/99.99'] = {'max': -0.50038558, 'min': -0.99402624} # lost: 0
limits['HW_tran/CG/nn_ang_norm/100.00'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['HW_tran/CG/nn_ang_norm/95.00'] = {'max': 50.733301428821051, 'min': 4.6861331390760483} # lost: 2
limits['HW_tran/CG/nn_ang_norm/99.00'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['HW_tran/CG/nn_ang_norm/99.50'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['HW_tran/CG/nn_ang_norm/99.90'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['HW_tran/CG/nn_ang_norm/99.99'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['HW_tran/CG/rot_ang/100.00'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['HW_tran/CG/rot_ang/95.00'] = {'max': 204.12031521835675, 'min': 156.66953390161615} # lost: 2
limits['HW_tran/CG/rot_ang/99.00'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['HW_tran/CG/rot_ang/99.50'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['HW_tran/CG/rot_ang/99.90'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['HW_tran/CG/rot_ang/99.99'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['HW_tran/CU/dist/100.00'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['HW_tran/CU/dist/95.00'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['HW_tran/CU/dist/99.00'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['HW_tran/CU/dist/99.50'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['HW_tran/CU/dist/99.90'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['HW_tran/CU/dist/99.99'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['HW_tran/CU/min_dist/100.00'] = {'max': 2.4053564877321461, 'min': 1.1477873188241137} # lost: 0
limits['HW_tran/CU/min_dist/95.00'] = {'max': 2.4053564877321461, 'min': 1.1477873188241137} # lost: 0
limits['HW_tran/CU/min_dist/99.00'] = {'max': 2.4053564877321461, 'min': 1.1477873188241137} # lost: 0
limits['HW_tran/CU/min_dist/99.50'] = {'max': 2.4053564877321461, 'min': 1.1477873188241137} # lost: 0
limits['HW_tran/CU/min_dist/99.90'] = {'max': 2.4053564877321461, 'min': 1.1477873188241137} # lost: 0
limits['HW_tran/CU/min_dist/99.99'] = {'max': 2.4053564877321461, 'min': 1.1477873188241137} # lost: 0
limits['HW_tran/CU/n2_z/100.00'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['HW_tran/CU/n2_z/95.00'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['HW_tran/CU/n2_z/99.00'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['HW_tran/CU/n2_z/99.50'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['HW_tran/CU/n2_z/99.90'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['HW_tran/CU/n2_z/99.99'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['HW_tran/CU/nn_ang_norm/100.00'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['HW_tran/CU/nn_ang_norm/95.00'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['HW_tran/CU/nn_ang_norm/99.00'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['HW_tran/CU/nn_ang_norm/99.50'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['HW_tran/CU/nn_ang_norm/99.90'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['HW_tran/CU/nn_ang_norm/99.99'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['HW_tran/CU/rot_ang/100.00'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['HW_tran/CU/rot_ang/95.00'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['HW_tran/CU/rot_ang/99.00'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['HW_tran/CU/rot_ang/99.50'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['HW_tran/CU/rot_ang/99.90'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['HW_tran/CU/rot_ang/99.99'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['HW_tran/GA/dist/100.00'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['HW_tran/GA/dist/95.00'] = {'max': 7.2955916486265657, 'min': 5.8446720394980689} # lost: 3
limits['HW_tran/GA/dist/99.00'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['HW_tran/GA/dist/99.50'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['HW_tran/GA/dist/99.90'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['HW_tran/GA/dist/99.99'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['HW_tran/GA/min_dist/100.00'] = {'max': 2.4915930538889248, 'min': 1.6374229458549814} # lost: 0
limits['HW_tran/GA/min_dist/95.00'] = {'max': 2.2873919958556801, 'min': 1.7052086943995959} # lost: 3
limits['HW_tran/GA/min_dist/99.00'] = {'max': 2.4915930538889248, 'min': 1.6374229458549814} # lost: 0
limits['HW_tran/GA/min_dist/99.50'] = {'max': 2.4915930538889248, 'min': 1.6374229458549814} # lost: 0
limits['HW_tran/GA/min_dist/99.90'] = {'max': 2.4915930538889248, 'min': 1.6374229458549814} # lost: 0
limits['HW_tran/GA/min_dist/99.99'] = {'max': 2.4915930538889248, 'min': 1.6374229458549814} # lost: 0
limits['HW_tran/GA/n2_z/100.00'] = {'max': -0.82131684, 'min': -0.9997521} # lost: 0
limits['HW_tran/GA/n2_z/95.00'] = {'max': -0.85194653, 'min': -0.9997521} # lost: 3
limits['HW_tran/GA/n2_z/99.00'] = {'max': -0.82131684, 'min': -0.9997521} # lost: 0
limits['HW_tran/GA/n2_z/99.50'] = {'max': -0.82131684, 'min': -0.9997521} # lost: 0
limits['HW_tran/GA/n2_z/99.90'] = {'max': -0.82131684, 'min': -0.9997521} # lost: 0
limits['HW_tran/GA/n2_z/99.99'] = {'max': -0.82131684, 'min': -0.9997521} # lost: 0
limits['HW_tran/GA/nn_ang_norm/100.00'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['HW_tran/GA/nn_ang_norm/95.00'] = {'max': 30.925370345190572, 'min': 1.5816482367651759} # lost: 3
limits['HW_tran/GA/nn_ang_norm/99.00'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['HW_tran/GA/nn_ang_norm/99.50'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['HW_tran/GA/nn_ang_norm/99.90'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['HW_tran/GA/nn_ang_norm/99.99'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['HW_tran/GA/rot_ang/100.00'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['HW_tran/GA/rot_ang/95.00'] = {'max': 211.38781113304748, 'min': 164.75073067472678} # lost: 3
limits['HW_tran/GA/rot_ang/99.00'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['HW_tran/GA/rot_ang/99.50'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['HW_tran/GA/rot_ang/99.90'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['HW_tran/GA/rot_ang/99.99'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['HW_tran/GC/dist/100.00'] = {'max': 7.7615443595762574, 'min': 6.0170071217883248} # lost: 0
limits['HW_tran/GC/dist/95.00'] = {'max': 7.4578755980205091, 'min': 6.17217400032958} # lost: 12
limits['HW_tran/GC/dist/99.00'] = {'max': 7.5781591179198085, 'min': 6.0396475759791413} # lost: 2
limits['HW_tran/GC/dist/99.50'] = {'max': 7.5781591179198085, 'min': 6.0170071217883248} # lost: 1
limits['HW_tran/GC/dist/99.90'] = {'max': 7.7615443595762574, 'min': 6.0170071217883248} # lost: 0
limits['HW_tran/GC/dist/99.99'] = {'max': 7.7615443595762574, 'min': 6.0170071217883248} # lost: 0
limits['HW_tran/GC/min_dist/100.00'] = {'max': 2.7260483452889446, 'min': 1.199769628191107} # lost: 0
limits['HW_tran/GC/min_dist/95.00'] = {'max': 2.6837140339105581, 'min': 1.532656266206657} # lost: 12
limits['HW_tran/GC/min_dist/99.00'] = {'max': 2.7177862587254151, 'min': 1.3710452037216236} # lost: 2
limits['HW_tran/GC/min_dist/99.50'] = {'max': 2.7177862587254151, 'min': 1.199769628191107} # lost: 1
limits['HW_tran/GC/min_dist/99.90'] = {'max': 2.7260483452889446, 'min': 1.199769628191107} # lost: 0
limits['HW_tran/GC/min_dist/99.99'] = {'max': 2.7260483452889446, 'min': 1.199769628191107} # lost: 0
limits['HW_tran/GC/n2_z/100.00'] = {'max': -0.48387697, 'min': -0.9997161} # lost: 0
limits['HW_tran/GC/n2_z/95.00'] = {'max': -0.82569659, 'min': -0.9997161} # lost: 12
limits['HW_tran/GC/n2_z/99.00'] = {'max': -0.62578499, 'min': -0.9997161} # lost: 2
limits['HW_tran/GC/n2_z/99.50'] = {'max': -0.5598641, 'min': -0.9997161} # lost: 1
limits['HW_tran/GC/n2_z/99.90'] = {'max': -0.48387697, 'min': -0.9997161} # lost: 0
limits['HW_tran/GC/n2_z/99.99'] = {'max': -0.48387697, 'min': -0.9997161} # lost: 0
limits['HW_tran/GC/nn_ang_norm/100.00'] = {'max': 59.993945113091144, 'min': 1.3369088984252926} # lost: 0
limits['HW_tran/GC/nn_ang_norm/95.00'] = {'max': 36.14543804102118, 'min': 1.3369088984252926} # lost: 12
limits['HW_tran/GC/nn_ang_norm/99.00'] = {'max': 51.819643016311574, 'min': 1.3369088984252926} # lost: 2
limits['HW_tran/GC/nn_ang_norm/99.50'] = {'max': 55.6968955213177, 'min': 1.3369088984252926} # lost: 1
limits['HW_tran/GC/nn_ang_norm/99.90'] = {'max': 59.993945113091144, 'min': 1.3369088984252926} # lost: 0
limits['HW_tran/GC/nn_ang_norm/99.99'] = {'max': 59.993945113091144, 'min': 1.3369088984252926} # lost: 0
limits['HW_tran/GC/rot_ang/100.00'] = {'max': 210.83460045495534, 'min': 141.9565148544327} # lost: 0
limits['HW_tran/GC/rot_ang/95.00'] = {'max': 198.05353408233887, 'min': 147.82045152562219} # lost: 12
limits['HW_tran/GC/rot_ang/99.00'] = {'max': 207.25140357764482, 'min': 142.2759521433133} # lost: 2
limits['HW_tran/GC/rot_ang/99.50'] = {'max': 207.25140357764482, 'min': 141.9565148544327} # lost: 1
limits['HW_tran/GC/rot_ang/99.90'] = {'max': 210.83460045495534, 'min': 141.9565148544327} # lost: 0
limits['HW_tran/GC/rot_ang/99.99'] = {'max': 210.83460045495534, 'min': 141.9565148544327} # lost: 0
limits['HW_tran/GG/dist/100.00'] = {'max': 7.8071466553036117, 'min': 5.5257457943629085} # lost: 0
limits['HW_tran/GG/dist/95.00'] = {'max': 7.3840221867671101, 'min': 5.84081257631426} # lost: 36
limits['HW_tran/GG/dist/99.00'] = {'max': 7.5458386568720508, 'min': 5.6951075727408433} # lost: 7
limits['HW_tran/GG/dist/99.50'] = {'max': 7.6247866597428509, 'min': 5.6194769503052253} # lost: 3
limits['HW_tran/GG/dist/99.90'] = {'max': 7.8071466553036117, 'min': 5.5257457943629085} # lost: 0
limits['HW_tran/GG/dist/99.99'] = {'max': 7.8071466553036117, 'min': 5.5257457943629085} # lost: 0
limits['HW_tran/GG/min_dist/100.00'] = {'max': 2.6613420090046418, 'min': 1.0508313431747118} # lost: 0
limits['HW_tran/GG/min_dist/95.00'] = {'max': 2.4081646874910581, 'min': 1.5378528913071936} # lost: 36
limits['HW_tran/GG/min_dist/99.00'] = {'max': 2.5238929395761986, 'min': 1.2146805308887363} # lost: 7
limits['HW_tran/GG/min_dist/99.50'] = {'max': 2.5298340980548257, 'min': 1.1064025239189645} # lost: 3
limits['HW_tran/GG/min_dist/99.90'] = {'max': 2.6613420090046418, 'min': 1.0508313431747118} # lost: 0
limits['HW_tran/GG/min_dist/99.99'] = {'max': 2.6613420090046418, 'min': 1.0508313431747118} # lost: 0
limits['HW_tran/GG/n2_z/100.00'] = {'max': -0.42652202, 'min': -0.99990958} # lost: 0
limits['HW_tran/GG/n2_z/95.00'] = {'max': -0.50937158, 'min': -0.99990958} # lost: 36
limits['HW_tran/GG/n2_z/99.00'] = {'max': -0.44264168, 'min': -0.99990958} # lost: 7
limits['HW_tran/GG/n2_z/99.50'] = {'max': -0.4326787, 'min': -0.99990958} # lost: 3
limits['HW_tran/GG/n2_z/99.90'] = {'max': -0.42652202, 'min': -0.99990958} # lost: 0
limits['HW_tran/GG/n2_z/99.99'] = {'max': -0.42652202, 'min': -0.99990958} # lost: 0
limits['HW_tran/GG/nn_ang_norm/100.00'] = {'max': 64.672542732279837, 'min': 0.60620160063896833} # lost: 0
limits['HW_tran/GG/nn_ang_norm/95.00'] = {'max': 59.834760724294824, 'min': 0.60620160063896833} # lost: 36
limits['HW_tran/GG/nn_ang_norm/99.00'] = {'max': 63.614286882656401, 'min': 0.60620160063896833} # lost: 7
limits['HW_tran/GG/nn_ang_norm/99.50'] = {'max': 63.96974358744221, 'min': 0.60620160063896833} # lost: 3
limits['HW_tran/GG/nn_ang_norm/99.90'] = {'max': 64.672542732279837, 'min': 0.60620160063896833} # lost: 0
limits['HW_tran/GG/nn_ang_norm/99.99'] = {'max': 64.672542732279837, 'min': 0.60620160063896833} # lost: 0
limits['HW_tran/GG/rot_ang/100.00'] = {'max': 233.55429160056622, 'min': 124.02435049132643} # lost: 0
limits['HW_tran/GG/rot_ang/95.00'] = {'max': 195.91744237793134, 'min': 134.9343931639294} # lost: 36
limits['HW_tran/GG/rot_ang/99.00'] = {'max': 204.47913846115063, 'min': 128.49244101108715} # lost: 7
limits['HW_tran/GG/rot_ang/99.50'] = {'max': 204.87066471173125, 'min': 124.6166265069652} # lost: 3
limits['HW_tran/GG/rot_ang/99.90'] = {'max': 233.55429160056622, 'min': 124.02435049132643} # lost: 0
limits['HW_tran/GG/rot_ang/99.99'] = {'max': 233.55429160056622, 'min': 124.02435049132643} # lost: 0
limits['HW_tran/GU/dist/100.00'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['HW_tran/GU/dist/95.00'] = {'max': 7.4619309258926663, 'min': 6.1307417301528115} # lost: 2
limits['HW_tran/GU/dist/99.00'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['HW_tran/GU/dist/99.50'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['HW_tran/GU/dist/99.90'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['HW_tran/GU/dist/99.99'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['HW_tran/GU/min_dist/100.00'] = {'max': 2.6446885097489092, 'min': 1.6552230789597309} # lost: 0
limits['HW_tran/GU/min_dist/95.00'] = {'max': 2.6241229260874093, 'min': 1.6833097103714514} # lost: 2
limits['HW_tran/GU/min_dist/99.00'] = {'max': 2.6446885097489092, 'min': 1.6552230789597309} # lost: 0
limits['HW_tran/GU/min_dist/99.50'] = {'max': 2.6446885097489092, 'min': 1.6552230789597309} # lost: 0
limits['HW_tran/GU/min_dist/99.90'] = {'max': 2.6446885097489092, 'min': 1.6552230789597309} # lost: 0
limits['HW_tran/GU/min_dist/99.99'] = {'max': 2.6446885097489092, 'min': 1.6552230789597309} # lost: 0
limits['HW_tran/GU/n2_z/100.00'] = {'max': -0.63674355, 'min': -0.99921179} # lost: 0
limits['HW_tran/GU/n2_z/95.00'] = {'max': -0.77130014, 'min': -0.99921179} # lost: 2
limits['HW_tran/GU/n2_z/99.00'] = {'max': -0.63674355, 'min': -0.99921179} # lost: 0
limits['HW_tran/GU/n2_z/99.50'] = {'max': -0.63674355, 'min': -0.99921179} # lost: 0
limits['HW_tran/GU/n2_z/99.90'] = {'max': -0.63674355, 'min': -0.99921179} # lost: 0
limits['HW_tran/GU/n2_z/99.99'] = {'max': -0.63674355, 'min': -0.99921179} # lost: 0
limits['HW_tran/GU/nn_ang_norm/100.00'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['HW_tran/GU/nn_ang_norm/95.00'] = {'max': 39.611772705180982, 'min': 3.1713201245722757} # lost: 2
limits['HW_tran/GU/nn_ang_norm/99.00'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['HW_tran/GU/nn_ang_norm/99.50'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['HW_tran/GU/nn_ang_norm/99.90'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['HW_tran/GU/nn_ang_norm/99.99'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['HW_tran/GU/rot_ang/100.00'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['HW_tran/GU/rot_ang/95.00'] = {'max': 210.52274912595155, 'min': 154.34850734596756} # lost: 2
limits['HW_tran/GU/rot_ang/99.00'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['HW_tran/GU/rot_ang/99.50'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['HW_tran/GU/rot_ang/99.90'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['HW_tran/GU/rot_ang/99.99'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['HW_tran/UA/dist/100.00'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['HW_tran/UA/dist/95.00'] = {'max': 7.4577840796651422, 'min': 5.2240893255266885} # lost: 1
limits['HW_tran/UA/dist/99.00'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['HW_tran/UA/dist/99.50'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['HW_tran/UA/dist/99.90'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['HW_tran/UA/dist/99.99'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['HW_tran/UA/min_dist/100.00'] = {'max': 2.2946596441430551, 'min': 1.244964730116781} # lost: 0
limits['HW_tran/UA/min_dist/95.00'] = {'max': 2.0936327075967021, 'min': 1.244964730116781} # lost: 1
limits['HW_tran/UA/min_dist/99.00'] = {'max': 2.2946596441430551, 'min': 1.244964730116781} # lost: 0
limits['HW_tran/UA/min_dist/99.50'] = {'max': 2.2946596441430551, 'min': 1.244964730116781} # lost: 0
limits['HW_tran/UA/min_dist/99.90'] = {'max': 2.2946596441430551, 'min': 1.244964730116781} # lost: 0
limits['HW_tran/UA/min_dist/99.99'] = {'max': 2.2946596441430551, 'min': 1.244964730116781} # lost: 0
limits['HW_tran/UA/n2_z/100.00'] = {'max': -0.44059235, 'min': -0.99481297} # lost: 0
limits['HW_tran/UA/n2_z/95.00'] = {'max': -0.4599902, 'min': -0.99481297} # lost: 1
limits['HW_tran/UA/n2_z/99.00'] = {'max': -0.44059235, 'min': -0.99481297} # lost: 0
limits['HW_tran/UA/n2_z/99.50'] = {'max': -0.44059235, 'min': -0.99481297} # lost: 0
limits['HW_tran/UA/n2_z/99.90'] = {'max': -0.44059235, 'min': -0.99481297} # lost: 0
limits['HW_tran/UA/n2_z/99.99'] = {'max': -0.44059235, 'min': -0.99481297} # lost: 0
limits['HW_tran/UA/nn_ang_norm/100.00'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['HW_tran/UA/nn_ang_norm/95.00'] = {'max': 63.612114882500336, 'min': 5.2441186131310644} # lost: 1
limits['HW_tran/UA/nn_ang_norm/99.00'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['HW_tran/UA/nn_ang_norm/99.50'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['HW_tran/UA/nn_ang_norm/99.90'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['HW_tran/UA/nn_ang_norm/99.99'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['HW_tran/UA/rot_ang/100.00'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['HW_tran/UA/rot_ang/95.00'] = {'max': 195.18901414888046, 'min': 151.66727253980827} # lost: 1
limits['HW_tran/UA/rot_ang/99.00'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['HW_tran/UA/rot_ang/99.50'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['HW_tran/UA/rot_ang/99.90'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['HW_tran/UA/rot_ang/99.99'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['HW_tran/UC/dist/100.00'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['HW_tran/UC/dist/95.00'] = {'max': 7.3165018350439155, 'min': 5.571139950170604} # lost: 1
limits['HW_tran/UC/dist/99.00'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['HW_tran/UC/dist/99.50'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['HW_tran/UC/dist/99.90'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['HW_tran/UC/dist/99.99'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['HW_tran/UC/min_dist/100.00'] = {'max': 2.319906294105246, 'min': 0.53450380910262785} # lost: 0
limits['HW_tran/UC/min_dist/95.00'] = {'max': 2.2627683756223615, 'min': 0.53450380910262785} # lost: 1
limits['HW_tran/UC/min_dist/99.00'] = {'max': 2.319906294105246, 'min': 0.53450380910262785} # lost: 0
limits['HW_tran/UC/min_dist/99.50'] = {'max': 2.319906294105246, 'min': 0.53450380910262785} # lost: 0
limits['HW_tran/UC/min_dist/99.90'] = {'max': 2.319906294105246, 'min': 0.53450380910262785} # lost: 0
limits['HW_tran/UC/min_dist/99.99'] = {'max': 2.319906294105246, 'min': 0.53450380910262785} # lost: 0
limits['HW_tran/UC/n2_z/100.00'] = {'max': -0.74776876, 'min': -0.99767423} # lost: 0
limits['HW_tran/UC/n2_z/95.00'] = {'max': -0.78747433, 'min': -0.99767423} # lost: 1
limits['HW_tran/UC/n2_z/99.00'] = {'max': -0.74776876, 'min': -0.99767423} # lost: 0
limits['HW_tran/UC/n2_z/99.50'] = {'max': -0.74776876, 'min': -0.99767423} # lost: 0
limits['HW_tran/UC/n2_z/99.90'] = {'max': -0.74776876, 'min': -0.99767423} # lost: 0
limits['HW_tran/UC/n2_z/99.99'] = {'max': -0.74776876, 'min': -0.99767423} # lost: 0
limits['HW_tran/UC/nn_ang_norm/100.00'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['HW_tran/UC/nn_ang_norm/95.00'] = {'max': 37.908596733746606, 'min': 3.8241359450637731} # lost: 1
limits['HW_tran/UC/nn_ang_norm/99.00'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['HW_tran/UC/nn_ang_norm/99.50'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['HW_tran/UC/nn_ang_norm/99.90'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['HW_tran/UC/nn_ang_norm/99.99'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['HW_tran/UC/rot_ang/100.00'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['HW_tran/UC/rot_ang/95.00'] = {'max': 168.92397879795305, 'min': 146.34327291062843} # lost: 1
limits['HW_tran/UC/rot_ang/99.00'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['HW_tran/UC/rot_ang/99.50'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['HW_tran/UC/rot_ang/99.90'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['HW_tran/UC/rot_ang/99.99'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['HW_tran/UG/dist/100.00'] = {'max': 6.9598799254501582, 'min': 5.447965287801865} # lost: 0
limits['HW_tran/UG/dist/95.00'] = {'max': 6.5562178546854346, 'min': 5.5505610617786738} # lost: 10
limits['HW_tran/UG/dist/99.00'] = {'max': 6.6741481954779189, 'min': 5.5217602393792049} # lost: 2
limits['HW_tran/UG/dist/99.50'] = {'max': 6.6741481954779189, 'min': 5.447965287801865} # lost: 1
limits['HW_tran/UG/dist/99.90'] = {'max': 6.9598799254501582, 'min': 5.447965287801865} # lost: 0
limits['HW_tran/UG/dist/99.99'] = {'max': 6.9598799254501582, 'min': 5.447965287801865} # lost: 0
limits['HW_tran/UG/min_dist/100.00'] = {'max': 2.5638865932884434, 'min': 0.91779370368684954} # lost: 0
limits['HW_tran/UG/min_dist/95.00'] = {'max': 2.4728681773840928, 'min': 1.3826257519494609} # lost: 10
limits['HW_tran/UG/min_dist/99.00'] = {'max': 2.5533941791924795, 'min': 1.1467612143322841} # lost: 2
limits['HW_tran/UG/min_dist/99.50'] = {'max': 2.5533941791924795, 'min': 0.91779370368684954} # lost: 1
limits['HW_tran/UG/min_dist/99.90'] = {'max': 2.5638865932884434, 'min': 0.91779370368684954} # lost: 0
limits['HW_tran/UG/min_dist/99.99'] = {'max': 2.5638865932884434, 'min': 0.91779370368684954} # lost: 0
limits['HW_tran/UG/n2_z/100.00'] = {'max': -0.44748938, 'min': -0.99735224} # lost: 0
limits['HW_tran/UG/n2_z/95.00'] = {'max': -0.46914461, 'min': -0.99735224} # lost: 10
limits['HW_tran/UG/n2_z/99.00'] = {'max': -0.44819245, 'min': -0.99735224} # lost: 2
limits['HW_tran/UG/n2_z/99.50'] = {'max': -0.44789109, 'min': -0.99735224} # lost: 1
limits['HW_tran/UG/n2_z/99.90'] = {'max': -0.44748938, 'min': -0.99735224} # lost: 0
limits['HW_tran/UG/n2_z/99.99'] = {'max': -0.44748938, 'min': -0.99735224} # lost: 0
limits['HW_tran/UG/nn_ang_norm/100.00'] = {'max': 63.471822796948274, 'min': 4.4979341066855341} # lost: 0
limits['HW_tran/UG/nn_ang_norm/95.00'] = {'max': 61.953567367102821, 'min': 4.4979341066855341} # lost: 10
limits['HW_tran/UG/nn_ang_norm/99.00'] = {'max': 63.232151458972538, 'min': 4.4979341066855341} # lost: 2
limits['HW_tran/UG/nn_ang_norm/99.50'] = {'max': 63.468380381606593, 'min': 4.4979341066855341} # lost: 1
limits['HW_tran/UG/nn_ang_norm/99.90'] = {'max': 63.471822796948274, 'min': 4.4979341066855341} # lost: 0
limits['HW_tran/UG/nn_ang_norm/99.99'] = {'max': 63.471822796948274, 'min': 4.4979341066855341} # lost: 0
limits['HW_tran/UG/rot_ang/100.00'] = {'max': 203.34145325660455, 'min': 135.21745931345157} # lost: 0
limits['HW_tran/UG/rot_ang/95.00'] = {'max': 191.85946010086872, 'min': 145.58777433620571} # lost: 10
limits['HW_tran/UG/rot_ang/99.00'] = {'max': 195.52280391289747, 'min': 142.77818911927014} # lost: 2
limits['HW_tran/UG/rot_ang/99.50'] = {'max': 195.52280391289747, 'min': 135.21745931345157} # lost: 1
limits['HW_tran/UG/rot_ang/99.90'] = {'max': 203.34145325660455, 'min': 135.21745931345157} # lost: 0
limits['HW_tran/UG/rot_ang/99.99'] = {'max': 203.34145325660455, 'min': 135.21745931345157} # lost: 0
limits['HW_tran/UU/dist/100.00'] = {'max': 6.8388242888229929, 'min': 5.2257914636473135} # lost: 0
limits['HW_tran/UU/dist/95.00'] = {'max': 6.55423341372052, 'min': 5.7054975384290767} # lost: 30
limits['HW_tran/UU/dist/99.00'] = {'max': 6.6529998507131332, 'min': 5.3929379872354861} # lost: 6
limits['HW_tran/UU/dist/99.50'] = {'max': 6.7346619126959517, 'min': 5.3030069567626557} # lost: 3
limits['HW_tran/UU/dist/99.90'] = {'max': 6.8388242888229929, 'min': 5.2257914636473135} # lost: 0
limits['HW_tran/UU/dist/99.99'] = {'max': 6.8388242888229929, 'min': 5.2257914636473135} # lost: 0
limits['HW_tran/UU/min_dist/100.00'] = {'max': 2.4284336665956494, 'min': 0.91571050646292018} # lost: 0
limits['HW_tran/UU/min_dist/95.00'] = {'max': 2.2819491800031617, 'min': 1.4123764259322675} # lost: 30
limits['HW_tran/UU/min_dist/99.00'] = {'max': 2.3482889116872734, 'min': 1.1958037737924161} # lost: 6
limits['HW_tran/UU/min_dist/99.50'] = {'max': 2.3539982445894858, 'min': 1.0981474545522198} # lost: 3
limits['HW_tran/UU/min_dist/99.90'] = {'max': 2.4284336665956494, 'min': 0.91571050646292018} # lost: 0
limits['HW_tran/UU/min_dist/99.99'] = {'max': 2.4284336665956494, 'min': 0.91571050646292018} # lost: 0
limits['HW_tran/UU/n2_z/100.00'] = {'max': -0.4560622, 'min': -0.99942976} # lost: 0
limits['HW_tran/UU/n2_z/95.00'] = {'max': -0.78890324, 'min': -0.99942976} # lost: 30
limits['HW_tran/UU/n2_z/99.00'] = {'max': -0.63681084, 'min': -0.99942976} # lost: 6
limits['HW_tran/UU/n2_z/99.50'] = {'max': -0.59405774, 'min': -0.99942976} # lost: 3
limits['HW_tran/UU/n2_z/99.90'] = {'max': -0.4560622, 'min': -0.99942976} # lost: 0
limits['HW_tran/UU/n2_z/99.99'] = {'max': -0.4560622, 'min': -0.99942976} # lost: 0
limits['HW_tran/UU/nn_ang_norm/100.00'] = {'max': 62.326304450488763, 'min': 1.9444132439628845} # lost: 0
limits['HW_tran/UU/nn_ang_norm/95.00'] = {'max': 37.506558138821333, 'min': 1.9444132439628845} # lost: 30
limits['HW_tran/UU/nn_ang_norm/99.00'] = {'max': 49.414719749171752, 'min': 1.9444132439628845} # lost: 6
limits['HW_tran/UU/nn_ang_norm/99.50'] = {'max': 53.692016433865518, 'min': 1.9444132439628845} # lost: 3
limits['HW_tran/UU/nn_ang_norm/99.90'] = {'max': 62.326304450488763, 'min': 1.9444132439628845} # lost: 0
limits['HW_tran/UU/nn_ang_norm/99.99'] = {'max': 62.326304450488763, 'min': 1.9444132439628845} # lost: 0
limits['HW_tran/UU/rot_ang/100.00'] = {'max': 204.39711019187692, 'min': 134.87072698425607} # lost: 0
limits['HW_tran/UU/rot_ang/95.00'] = {'max': 176.48322335101449, 'min': 142.03490065250426} # lost: 30
limits['HW_tran/UU/rot_ang/99.00'] = {'max': 190.59934224804704, 'min': 138.97629704528509} # lost: 6
limits['HW_tran/UU/rot_ang/99.50'] = {'max': 190.64216104216425, 'min': 138.55649370136905} # lost: 3
limits['HW_tran/UU/rot_ang/99.90'] = {'max': 204.39711019187692, 'min': 134.87072698425607} # lost: 0
limits['HW_tran/UU/rot_ang/99.99'] = {'max': 204.39711019187692, 'min': 134.87072698425607} # lost: 0
limits['SH_cis/AA/dist/100.00'] = {'max': 7.2734486264790643, 'min': 6.0401432364464993} # lost: 0
limits['SH_cis/AA/dist/95.00'] = {'max': 7.0792412283118455, 'min': 6.310055800903033} # lost: 43
limits['SH_cis/AA/dist/99.00'] = {'max': 7.1732548918851649, 'min': 6.2108820950972623} # lost: 8
limits['SH_cis/AA/dist/99.50'] = {'max': 7.2050976980790553, 'min': 6.191231068220679} # lost: 4
limits['SH_cis/AA/dist/99.90'] = {'max': 7.2734486264790643, 'min': 6.0401432364464993} # lost: 0
limits['SH_cis/AA/dist/99.99'] = {'max': 7.2734486264790643, 'min': 6.0401432364464993} # lost: 0
limits['SH_cis/AA/min_dist/100.00'] = {'max': 2.620981294677053, 'min': 1.1749104750455186} # lost: 0
limits['SH_cis/AA/min_dist/95.00'] = {'max': 2.4357696221641074, 'min': 1.7602627781670415} # lost: 43
limits['SH_cis/AA/min_dist/99.00'] = {'max': 2.5397604837514036, 'min': 1.5907477014570508} # lost: 8
limits['SH_cis/AA/min_dist/99.50'] = {'max': 2.5484614167010786, 'min': 1.4676513491865759} # lost: 4
limits['SH_cis/AA/min_dist/99.90'] = {'max': 2.620981294677053, 'min': 1.1749104750455186} # lost: 0
limits['SH_cis/AA/min_dist/99.99'] = {'max': 2.620981294677053, 'min': 1.1749104750455186} # lost: 0
limits['SH_cis/AA/n2_z/100.00'] = {'max': 0.9999339, 'min': 0.42615524} # lost: 0
limits['SH_cis/AA/n2_z/95.00'] = {'max': 0.9999339, 'min': 0.60578275} # lost: 43
limits['SH_cis/AA/n2_z/99.00'] = {'max': 0.9999339, 'min': 0.44327447} # lost: 8
limits['SH_cis/AA/n2_z/99.50'] = {'max': 0.9999339, 'min': 0.43651527} # lost: 4
limits['SH_cis/AA/n2_z/99.90'] = {'max': 0.9999339, 'min': 0.42615524} # lost: 0
limits['SH_cis/AA/n2_z/99.99'] = {'max': 0.9999339, 'min': 0.42615524} # lost: 0
limits['SH_cis/AA/nn_ang_norm/100.00'] = {'max': 64.950563761212379, 'min': 0.48213889136467464} # lost: 0
limits['SH_cis/AA/nn_ang_norm/95.00'] = {'max': 52.581562457372009, 'min': 0.48213889136467464} # lost: 43
limits['SH_cis/AA/nn_ang_norm/99.00'] = {'max': 63.930379386022587, 'min': 0.48213889136467464} # lost: 8
limits['SH_cis/AA/nn_ang_norm/99.50'] = {'max': 64.306367639453455, 'min': 0.48213889136467464} # lost: 4
limits['SH_cis/AA/nn_ang_norm/99.90'] = {'max': 64.950563761212379, 'min': 0.48213889136467464} # lost: 0
limits['SH_cis/AA/nn_ang_norm/99.99'] = {'max': 64.950563761212379, 'min': 0.48213889136467464} # lost: 0
limits['SH_cis/AA/rot_ang/100.00'] = {'max': 66.86282522282383, 'min': -50.409115140002605} # lost: 0
limits['SH_cis/AA/rot_ang/95.00'] = {'max': 62.435526692326761, 'min': -30.945979976794721} # lost: 43
limits['SH_cis/AA/rot_ang/99.00'] = {'max': 64.838059473594413, 'min': -41.808248048549594} # lost: 8
limits['SH_cis/AA/rot_ang/99.50'] = {'max': 65.133476004140192, 'min': -42.649062419662016} # lost: 4
limits['SH_cis/AA/rot_ang/99.90'] = {'max': 66.86282522282383, 'min': -50.409115140002605} # lost: 0
limits['SH_cis/AA/rot_ang/99.99'] = {'max': 66.86282522282383, 'min': -50.409115140002605} # lost: 0
limits['SH_cis/AC/dist/100.00'] = {'max': 7.0978163103048404, 'min': 5.8205611387670464} # lost: 0
limits['SH_cis/AC/dist/95.00'] = {'max': 6.9231173330934039, 'min': 5.9129147499167747} # lost: 15
limits['SH_cis/AC/dist/99.00'] = {'max': 6.9772710818839414, 'min': 5.8264379983139056} # lost: 3
limits['SH_cis/AC/dist/99.50'] = {'max': 7.0091616235151832, 'min': 5.8205611387670464} # lost: 1
limits['SH_cis/AC/dist/99.90'] = {'max': 7.0978163103048404, 'min': 5.8205611387670464} # lost: 0
limits['SH_cis/AC/dist/99.99'] = {'max': 7.0978163103048404, 'min': 5.8205611387670464} # lost: 0
limits['SH_cis/AC/min_dist/100.00'] = {'max': 2.53742336368812, 'min': 1.2376790124854486} # lost: 0
limits['SH_cis/AC/min_dist/95.00'] = {'max': 2.466963275134165, 'min': 1.7201962991147166} # lost: 15
limits['SH_cis/AC/min_dist/99.00'] = {'max': 2.5183596892632729, 'min': 1.2388117664295226} # lost: 3
limits['SH_cis/AC/min_dist/99.50'] = {'max': 2.5188668691719811, 'min': 1.2376790124854486} # lost: 1
limits['SH_cis/AC/min_dist/99.90'] = {'max': 2.53742336368812, 'min': 1.2376790124854486} # lost: 0
limits['SH_cis/AC/min_dist/99.99'] = {'max': 2.53742336368812, 'min': 1.2376790124854486} # lost: 0
limits['SH_cis/AC/n2_z/100.00'] = {'max': 0.99983472, 'min': 0.46589476} # lost: 0
limits['SH_cis/AC/n2_z/95.00'] = {'max': 0.99983472, 'min': 0.80668098} # lost: 15
limits['SH_cis/AC/n2_z/99.00'] = {'max': 0.99983472, 'min': 0.59106046} # lost: 3
limits['SH_cis/AC/n2_z/99.50'] = {'max': 0.99983472, 'min': 0.47789276} # lost: 1
limits['SH_cis/AC/n2_z/99.90'] = {'max': 0.99983472, 'min': 0.46589476} # lost: 0
limits['SH_cis/AC/n2_z/99.99'] = {'max': 0.99983472, 'min': 0.46589476} # lost: 0
limits['SH_cis/AC/nn_ang_norm/100.00'] = {'max': 61.717985491207081, 'min': 1.0061934797269538} # lost: 0
limits['SH_cis/AC/nn_ang_norm/95.00'] = {'max': 36.624095876822842, 'min': 1.0061934797269538} # lost: 15
limits['SH_cis/AC/nn_ang_norm/99.00'] = {'max': 53.332569077371595, 'min': 1.0061934797269538} # lost: 3
limits['SH_cis/AC/nn_ang_norm/99.50'] = {'max': 60.047553446653737, 'min': 1.0061934797269538} # lost: 1
limits['SH_cis/AC/nn_ang_norm/99.90'] = {'max': 61.717985491207081, 'min': 1.0061934797269538} # lost: 0
limits['SH_cis/AC/nn_ang_norm/99.99'] = {'max': 61.717985491207081, 'min': 1.0061934797269538} # lost: 0
limits['SH_cis/AC/rot_ang/100.00'] = {'max': 66.185754738727965, 'min': -61.563761249840162} # lost: 0
limits['SH_cis/AC/rot_ang/95.00'] = {'max': 46.087087738102191, 'min': -35.186299294536234} # lost: 15
limits['SH_cis/AC/rot_ang/99.00'] = {'max': 59.093130406938826, 'min': -50.666386110339509} # lost: 3
limits['SH_cis/AC/rot_ang/99.50'] = {'max': 62.30455966018615, 'min': -61.563761249840162} # lost: 1
limits['SH_cis/AC/rot_ang/99.90'] = {'max': 66.185754738727965, 'min': -61.563761249840162} # lost: 0
limits['SH_cis/AC/rot_ang/99.99'] = {'max': 66.185754738727965, 'min': -61.563761249840162} # lost: 0
limits['SH_cis/AG/dist/100.00'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['SH_cis/AG/dist/95.00'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['SH_cis/AG/dist/99.00'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['SH_cis/AG/dist/99.50'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['SH_cis/AG/dist/99.90'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['SH_cis/AG/dist/99.99'] = {'max': 7.1428053008219816, 'min': 5.9427137479918875} # lost: 0
limits['SH_cis/AG/min_dist/100.00'] = {'max': 2.74954934244766, 'min': 1.5408371477870186} # lost: 0
limits['SH_cis/AG/min_dist/95.00'] = {'max': 2.74954934244766, 'min': 1.5408371477870186} # lost: 0
limits['SH_cis/AG/min_dist/99.00'] = {'max': 2.74954934244766, 'min': 1.5408371477870186} # lost: 0
limits['SH_cis/AG/min_dist/99.50'] = {'max': 2.74954934244766, 'min': 1.5408371477870186} # lost: 0
limits['SH_cis/AG/min_dist/99.90'] = {'max': 2.74954934244766, 'min': 1.5408371477870186} # lost: 0
limits['SH_cis/AG/min_dist/99.99'] = {'max': 2.74954934244766, 'min': 1.5408371477870186} # lost: 0
limits['SH_cis/AG/n2_z/100.00'] = {'max': 0.99651498, 'min': 0.97114873} # lost: 0
limits['SH_cis/AG/n2_z/95.00'] = {'max': 0.99651498, 'min': 0.97114873} # lost: 0
limits['SH_cis/AG/n2_z/99.00'] = {'max': 0.99651498, 'min': 0.97114873} # lost: 0
limits['SH_cis/AG/n2_z/99.50'] = {'max': 0.99651498, 'min': 0.97114873} # lost: 0
limits['SH_cis/AG/n2_z/99.90'] = {'max': 0.99651498, 'min': 0.97114873} # lost: 0
limits['SH_cis/AG/n2_z/99.99'] = {'max': 0.99651498, 'min': 0.97114873} # lost: 0
limits['SH_cis/AG/nn_ang_norm/100.00'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['SH_cis/AG/nn_ang_norm/95.00'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['SH_cis/AG/nn_ang_norm/99.00'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['SH_cis/AG/nn_ang_norm/99.50'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['SH_cis/AG/nn_ang_norm/99.90'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['SH_cis/AG/nn_ang_norm/99.99'] = {'max': 13.47824707693888, 'min': 4.2353559080953014} # lost: 0
limits['SH_cis/AG/rot_ang/100.00'] = {'max': 24.106664486161677, 'min': -9.8995261848606049} # lost: 0
limits['SH_cis/AG/rot_ang/95.00'] = {'max': 24.106664486161677, 'min': -9.8995261848606049} # lost: 0
limits['SH_cis/AG/rot_ang/99.00'] = {'max': 24.106664486161677, 'min': -9.8995261848606049} # lost: 0
limits['SH_cis/AG/rot_ang/99.50'] = {'max': 24.106664486161677, 'min': -9.8995261848606049} # lost: 0
limits['SH_cis/AG/rot_ang/99.90'] = {'max': 24.106664486161677, 'min': -9.8995261848606049} # lost: 0
limits['SH_cis/AG/rot_ang/99.99'] = {'max': 24.106664486161677, 'min': -9.8995261848606049} # lost: 0
limits['SH_cis/AU/dist/100.00'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['SH_cis/AU/dist/95.00'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['SH_cis/AU/dist/99.00'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['SH_cis/AU/dist/99.50'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['SH_cis/AU/dist/99.90'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['SH_cis/AU/dist/99.99'] = {'max': 6.3950243871349057, 'min': 5.2803082443353384} # lost: 0
limits['SH_cis/AU/min_dist/100.00'] = {'max': 2.6047445001116776, 'min': 1.3489668853339787} # lost: 0
limits['SH_cis/AU/min_dist/95.00'] = {'max': 2.6047445001116776, 'min': 1.3489668853339787} # lost: 0
limits['SH_cis/AU/min_dist/99.00'] = {'max': 2.6047445001116776, 'min': 1.3489668853339787} # lost: 0
limits['SH_cis/AU/min_dist/99.50'] = {'max': 2.6047445001116776, 'min': 1.3489668853339787} # lost: 0
limits['SH_cis/AU/min_dist/99.90'] = {'max': 2.6047445001116776, 'min': 1.3489668853339787} # lost: 0
limits['SH_cis/AU/min_dist/99.99'] = {'max': 2.6047445001116776, 'min': 1.3489668853339787} # lost: 0
limits['SH_cis/AU/n2_z/100.00'] = {'max': 0.99715585, 'min': 0.88514793} # lost: 0
limits['SH_cis/AU/n2_z/95.00'] = {'max': 0.99715585, 'min': 0.88514793} # lost: 0
limits['SH_cis/AU/n2_z/99.00'] = {'max': 0.99715585, 'min': 0.88514793} # lost: 0
limits['SH_cis/AU/n2_z/99.50'] = {'max': 0.99715585, 'min': 0.88514793} # lost: 0
limits['SH_cis/AU/n2_z/99.90'] = {'max': 0.99715585, 'min': 0.88514793} # lost: 0
limits['SH_cis/AU/n2_z/99.99'] = {'max': 0.99715585, 'min': 0.88514793} # lost: 0
limits['SH_cis/AU/nn_ang_norm/100.00'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['SH_cis/AU/nn_ang_norm/95.00'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['SH_cis/AU/nn_ang_norm/99.00'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['SH_cis/AU/nn_ang_norm/99.50'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['SH_cis/AU/nn_ang_norm/99.90'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['SH_cis/AU/nn_ang_norm/99.99'] = {'max': 29.232164628711562, 'min': 7.6840072124939498} # lost: 0
limits['SH_cis/AU/rot_ang/100.00'] = {'max': 28.075447541112879, 'min': -11.330224940467776} # lost: 0
limits['SH_cis/AU/rot_ang/95.00'] = {'max': 28.075447541112879, 'min': -11.330224940467776} # lost: 0
limits['SH_cis/AU/rot_ang/99.00'] = {'max': 28.075447541112879, 'min': -11.330224940467776} # lost: 0
limits['SH_cis/AU/rot_ang/99.50'] = {'max': 28.075447541112879, 'min': -11.330224940467776} # lost: 0
limits['SH_cis/AU/rot_ang/99.90'] = {'max': 28.075447541112879, 'min': -11.330224940467776} # lost: 0
limits['SH_cis/AU/rot_ang/99.99'] = {'max': 28.075447541112879, 'min': -11.330224940467776} # lost: 0
limits['SH_cis/CA/dist/100.00'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['SH_cis/CA/dist/95.00'] = {'max': 8.0470644404376621, 'min': 7.0820862929844912} # lost: 5
limits['SH_cis/CA/dist/99.00'] = {'max': 8.1756319103011155, 'min': 7.0431558855584955} # lost: 1
limits['SH_cis/CA/dist/99.50'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['SH_cis/CA/dist/99.90'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['SH_cis/CA/dist/99.99'] = {'max': 8.1826354068200526, 'min': 7.0431558855584955} # lost: 0
limits['SH_cis/CA/min_dist/100.00'] = {'max': 2.4428068229696831, 'min': 1.5223173423047189} # lost: 0
limits['SH_cis/CA/min_dist/95.00'] = {'max': 2.4332233450934631, 'min': 1.5457087212046516} # lost: 5
limits['SH_cis/CA/min_dist/99.00'] = {'max': 2.4356856154846049, 'min': 1.5223173423047189} # lost: 1
limits['SH_cis/CA/min_dist/99.50'] = {'max': 2.4428068229696831, 'min': 1.5223173423047189} # lost: 0
limits['SH_cis/CA/min_dist/99.90'] = {'max': 2.4428068229696831, 'min': 1.5223173423047189} # lost: 0
limits['SH_cis/CA/min_dist/99.99'] = {'max': 2.4428068229696831, 'min': 1.5223173423047189} # lost: 0
limits['SH_cis/CA/n2_z/100.00'] = {'max': 0.99312353, 'min': 0.49190822} # lost: 0
limits['SH_cis/CA/n2_z/95.00'] = {'max': 0.99312353, 'min': 0.5838387} # lost: 5
limits['SH_cis/CA/n2_z/99.00'] = {'max': 0.99312353, 'min': 0.49255666} # lost: 1
limits['SH_cis/CA/n2_z/99.50'] = {'max': 0.99312353, 'min': 0.49190822} # lost: 0
limits['SH_cis/CA/n2_z/99.90'] = {'max': 0.99312353, 'min': 0.49190822} # lost: 0
limits['SH_cis/CA/n2_z/99.99'] = {'max': 0.99312353, 'min': 0.49190822} # lost: 0
limits['SH_cis/CA/nn_ang_norm/100.00'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['SH_cis/CA/nn_ang_norm/95.00'] = {'max': 54.125093002241101, 'min': 6.6184097632863965} # lost: 5
limits['SH_cis/CA/nn_ang_norm/99.00'] = {'max': 60.215405345506802, 'min': 6.6184097632863965} # lost: 1
limits['SH_cis/CA/nn_ang_norm/99.50'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['SH_cis/CA/nn_ang_norm/99.90'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['SH_cis/CA/nn_ang_norm/99.99'] = {'max': 60.542755821858002, 'min': 6.6184097632863965} # lost: 0
limits['SH_cis/CA/rot_ang/100.00'] = {'max': 62.552800567610674, 'min': -44.034730620421591} # lost: 0
limits['SH_cis/CA/rot_ang/95.00'] = {'max': 61.934095150906273, 'min': -41.186040924339693} # lost: 5
limits['SH_cis/CA/rot_ang/99.00'] = {'max': 62.250734575183742, 'min': -44.034730620421591} # lost: 1
limits['SH_cis/CA/rot_ang/99.50'] = {'max': 62.552800567610674, 'min': -44.034730620421591} # lost: 0
limits['SH_cis/CA/rot_ang/99.90'] = {'max': 62.552800567610674, 'min': -44.034730620421591} # lost: 0
limits['SH_cis/CA/rot_ang/99.99'] = {'max': 62.552800567610674, 'min': -44.034730620421591} # lost: 0
limits['SH_cis/CC/dist/100.00'] = {'max': 7.9513208589721032, 'min': 6.0268202836328086} # lost: 0
limits['SH_cis/CC/dist/95.00'] = {'max': 7.9088713847617607, 'min': 6.1688169546846012} # lost: 11
limits['SH_cis/CC/dist/99.00'] = {'max': 7.9367526983363526, 'min': 6.0795613711538703} # lost: 2
limits['SH_cis/CC/dist/99.50'] = {'max': 7.9367526983363526, 'min': 6.0268202836328086} # lost: 1
limits['SH_cis/CC/dist/99.90'] = {'max': 7.9513208589721032, 'min': 6.0268202836328086} # lost: 0
limits['SH_cis/CC/dist/99.99'] = {'max': 7.9513208589721032, 'min': 6.0268202836328086} # lost: 0
limits['SH_cis/CC/min_dist/100.00'] = {'max': 2.5438146239544941, 'min': 1.312526817623775} # lost: 0
limits['SH_cis/CC/min_dist/95.00'] = {'max': 2.488218659241229, 'min': 1.6077514827608217} # lost: 11
limits['SH_cis/CC/min_dist/99.00'] = {'max': 2.5108847614338736, 'min': 1.5351133964207417} # lost: 2
limits['SH_cis/CC/min_dist/99.50'] = {'max': 2.5108847614338736, 'min': 1.312526817623775} # lost: 1
limits['SH_cis/CC/min_dist/99.90'] = {'max': 2.5438146239544941, 'min': 1.312526817623775} # lost: 0
limits['SH_cis/CC/min_dist/99.99'] = {'max': 2.5438146239544941, 'min': 1.312526817623775} # lost: 0
limits['SH_cis/CC/n2_z/100.00'] = {'max': 0.99615091, 'min': 0.46561107} # lost: 0
limits['SH_cis/CC/n2_z/95.00'] = {'max': 0.99615091, 'min': 0.60264099} # lost: 11
limits['SH_cis/CC/n2_z/99.00'] = {'max': 0.99615091, 'min': 0.54016507} # lost: 2
limits['SH_cis/CC/n2_z/99.50'] = {'max': 0.99615091, 'min': 0.52319092} # lost: 1
limits['SH_cis/CC/n2_z/99.90'] = {'max': 0.99615091, 'min': 0.46561107} # lost: 0
limits['SH_cis/CC/n2_z/99.99'] = {'max': 0.99615091, 'min': 0.46561107} # lost: 0
limits['SH_cis/CC/nn_ang_norm/100.00'] = {'max': 60.451620607762521, 'min': 4.0887339447299302} # lost: 0
limits['SH_cis/CC/nn_ang_norm/95.00'] = {'max': 53.381435665788452, 'min': 4.0887339447299302} # lost: 11
limits['SH_cis/CC/nn_ang_norm/99.00'] = {'max': 57.472797525801546, 'min': 4.0887339447299302} # lost: 2
limits['SH_cis/CC/nn_ang_norm/99.50'] = {'max': 58.302446943904656, 'min': 4.0887339447299302} # lost: 1
limits['SH_cis/CC/nn_ang_norm/99.90'] = {'max': 60.451620607762521, 'min': 4.0887339447299302} # lost: 0
limits['SH_cis/CC/nn_ang_norm/99.99'] = {'max': 60.451620607762521, 'min': 4.0887339447299302} # lost: 0
limits['SH_cis/CC/rot_ang/100.00'] = {'max': 66.610379870463817, 'min': -68.097760343752952} # lost: 0
limits['SH_cis/CC/rot_ang/95.00'] = {'max': 63.222815230679025, 'min': -51.997342249687073} # lost: 11
limits['SH_cis/CC/rot_ang/99.00'] = {'max': 65.937500657361127, 'min': -54.610419237998464} # lost: 2
limits['SH_cis/CC/rot_ang/99.50'] = {'max': 65.937500657361127, 'min': -68.097760343752952} # lost: 1
limits['SH_cis/CC/rot_ang/99.90'] = {'max': 66.610379870463817, 'min': -68.097760343752952} # lost: 0
limits['SH_cis/CC/rot_ang/99.99'] = {'max': 66.610379870463817, 'min': -68.097760343752952} # lost: 0
limits['SH_cis/CU/dist/100.00'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['SH_cis/CU/dist/95.00'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['SH_cis/CU/dist/99.00'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['SH_cis/CU/dist/99.50'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['SH_cis/CU/dist/99.90'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['SH_cis/CU/dist/99.99'] = {'max': 7.0794955469735026, 'min': 6.8101727325562491} # lost: 0
limits['SH_cis/CU/min_dist/100.00'] = {'max': 2.4476114401581159, 'min': 2.1599301907977497} # lost: 0
limits['SH_cis/CU/min_dist/95.00'] = {'max': 2.4476114401581159, 'min': 2.1599301907977497} # lost: 0
limits['SH_cis/CU/min_dist/99.00'] = {'max': 2.4476114401581159, 'min': 2.1599301907977497} # lost: 0
limits['SH_cis/CU/min_dist/99.50'] = {'max': 2.4476114401581159, 'min': 2.1599301907977497} # lost: 0
limits['SH_cis/CU/min_dist/99.90'] = {'max': 2.4476114401581159, 'min': 2.1599301907977497} # lost: 0
limits['SH_cis/CU/min_dist/99.99'] = {'max': 2.4476114401581159, 'min': 2.1599301907977497} # lost: 0
limits['SH_cis/CU/n2_z/100.00'] = {'max': 0.96807694, 'min': 0.8774367} # lost: 0
limits['SH_cis/CU/n2_z/95.00'] = {'max': 0.96807694, 'min': 0.8774367} # lost: 0
limits['SH_cis/CU/n2_z/99.00'] = {'max': 0.96807694, 'min': 0.8774367} # lost: 0
limits['SH_cis/CU/n2_z/99.50'] = {'max': 0.96807694, 'min': 0.8774367} # lost: 0
limits['SH_cis/CU/n2_z/99.90'] = {'max': 0.96807694, 'min': 0.8774367} # lost: 0
limits['SH_cis/CU/n2_z/99.99'] = {'max': 0.96807694, 'min': 0.8774367} # lost: 0
limits['SH_cis/CU/nn_ang_norm/100.00'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['SH_cis/CU/nn_ang_norm/95.00'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['SH_cis/CU/nn_ang_norm/99.00'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['SH_cis/CU/nn_ang_norm/99.50'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['SH_cis/CU/nn_ang_norm/99.90'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['SH_cis/CU/nn_ang_norm/99.99'] = {'max': 30.856547537880676, 'min': 15.56737227893494} # lost: 0
limits['SH_cis/CU/rot_ang/100.00'] = {'max': -23.271058712123022, 'min': -29.693367976884055} # lost: 0
limits['SH_cis/CU/rot_ang/95.00'] = {'max': -23.271058712123022, 'min': -29.693367976884055} # lost: 0
limits['SH_cis/CU/rot_ang/99.00'] = {'max': -23.271058712123022, 'min': -29.693367976884055} # lost: 0
limits['SH_cis/CU/rot_ang/99.50'] = {'max': -23.271058712123022, 'min': -29.693367976884055} # lost: 0
limits['SH_cis/CU/rot_ang/99.90'] = {'max': -23.271058712123022, 'min': -29.693367976884055} # lost: 0
limits['SH_cis/CU/rot_ang/99.99'] = {'max': -23.271058712123022, 'min': -29.693367976884055} # lost: 0
limits['SH_cis/GA/dist/100.00'] = {'max': 8.0474746668053569, 'min': 6.2974806011590827} # lost: 0
limits['SH_cis/GA/dist/95.00'] = {'max': 7.6911476646377475, 'min': 6.4922229132104734} # lost: 20
limits['SH_cis/GA/dist/99.00'] = {'max': 7.913851279243624, 'min': 6.3337426798914187} # lost: 4
limits['SH_cis/GA/dist/99.50'] = {'max': 7.9995659131035488, 'min': 6.3011088031617177} # lost: 2
limits['SH_cis/GA/dist/99.90'] = {'max': 8.0474746668053569, 'min': 6.2974806011590827} # lost: 0
limits['SH_cis/GA/dist/99.99'] = {'max': 8.0474746668053569, 'min': 6.2974806011590827} # lost: 0
limits['SH_cis/GA/min_dist/100.00'] = {'max': 2.5837713670908302, 'min': 0.44494630868549179} # lost: 0
limits['SH_cis/GA/min_dist/95.00'] = {'max': 2.3709583148598958, 'min': 1.2450052121631092} # lost: 20
limits['SH_cis/GA/min_dist/99.00'] = {'max': 2.511466797895479, 'min': 0.97924854379583204} # lost: 4
limits['SH_cis/GA/min_dist/99.50'] = {'max': 2.5687338726129667, 'min': 0.85339243985568991} # lost: 2
limits['SH_cis/GA/min_dist/99.90'] = {'max': 2.5837713670908302, 'min': 0.44494630868549179} # lost: 0
limits['SH_cis/GA/min_dist/99.99'] = {'max': 2.5837713670908302, 'min': 0.44494630868549179} # lost: 0
limits['SH_cis/GA/n2_z/100.00'] = {'max': 0.99974871, 'min': 0.43494615} # lost: 0
limits['SH_cis/GA/n2_z/95.00'] = {'max': 0.99974871, 'min': 0.60834551} # lost: 20
limits['SH_cis/GA/n2_z/99.00'] = {'max': 0.99974871, 'min': 0.45711559} # lost: 4
limits['SH_cis/GA/n2_z/99.50'] = {'max': 0.99974871, 'min': 0.44777611} # lost: 2
limits['SH_cis/GA/n2_z/99.90'] = {'max': 0.99974871, 'min': 0.43494615} # lost: 0
limits['SH_cis/GA/n2_z/99.99'] = {'max': 0.99974871, 'min': 0.43494615} # lost: 0
limits['SH_cis/GA/nn_ang_norm/100.00'] = {'max': 63.934853159928949, 'min': 1.1691884737499034} # lost: 0
limits['SH_cis/GA/nn_ang_norm/95.00'] = {'max': 52.822814984140621, 'min': 1.1691884737499034} # lost: 20
limits['SH_cis/GA/nn_ang_norm/99.00'] = {'max': 62.516830756153432, 'min': 1.1691884737499034} # lost: 4
limits['SH_cis/GA/nn_ang_norm/99.50'] = {'max': 63.214643862896949, 'min': 1.1691884737499034} # lost: 2
limits['SH_cis/GA/nn_ang_norm/99.90'] = {'max': 63.934853159928949, 'min': 1.1691884737499034} # lost: 0
limits['SH_cis/GA/nn_ang_norm/99.99'] = {'max': 63.934853159928949, 'min': 1.1691884737499034} # lost: 0
limits['SH_cis/GA/rot_ang/100.00'] = {'max': 64.770032249991388, 'min': -78.281166807908775} # lost: 0
limits['SH_cis/GA/rot_ang/95.00'] = {'max': 53.404360788312978, 'min': -61.675749575231563} # lost: 20
limits['SH_cis/GA/rot_ang/99.00'] = {'max': 64.037782861260382, 'min': -70.383244953955781} # lost: 4
limits['SH_cis/GA/rot_ang/99.50'] = {'max': 64.232241347008667, 'min': -70.865649799681265} # lost: 2
limits['SH_cis/GA/rot_ang/99.90'] = {'max': 64.770032249991388, 'min': -78.281166807908775} # lost: 0
limits['SH_cis/GA/rot_ang/99.99'] = {'max': 64.770032249991388, 'min': -78.281166807908775} # lost: 0
limits['SH_cis/GC/dist/100.00'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['SH_cis/GC/dist/95.00'] = {'max': 7.063937620576942, 'min': 5.6717686624084278} # lost: 2
limits['SH_cis/GC/dist/99.00'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['SH_cis/GC/dist/99.50'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['SH_cis/GC/dist/99.90'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['SH_cis/GC/dist/99.99'] = {'max': 7.083474249644774, 'min': 5.5572136373542804} # lost: 0
limits['SH_cis/GC/min_dist/100.00'] = {'max': 2.6151389049403608, 'min': 0.86230562973235625} # lost: 0
limits['SH_cis/GC/min_dist/95.00'] = {'max': 2.5735523268305021, 'min': 1.1795991764281293} # lost: 2
limits['SH_cis/GC/min_dist/99.00'] = {'max': 2.6151389049403608, 'min': 0.86230562973235625} # lost: 0
limits['SH_cis/GC/min_dist/99.50'] = {'max': 2.6151389049403608, 'min': 0.86230562973235625} # lost: 0
limits['SH_cis/GC/min_dist/99.90'] = {'max': 2.6151389049403608, 'min': 0.86230562973235625} # lost: 0
limits['SH_cis/GC/min_dist/99.99'] = {'max': 2.6151389049403608, 'min': 0.86230562973235625} # lost: 0
limits['SH_cis/GC/n2_z/100.00'] = {'max': 0.99990505, 'min': 0.70588058} # lost: 0
limits['SH_cis/GC/n2_z/95.00'] = {'max': 0.99990505, 'min': 0.70589519} # lost: 2
limits['SH_cis/GC/n2_z/99.00'] = {'max': 0.99990505, 'min': 0.70588058} # lost: 0
limits['SH_cis/GC/n2_z/99.50'] = {'max': 0.99990505, 'min': 0.70588058} # lost: 0
limits['SH_cis/GC/n2_z/99.90'] = {'max': 0.99990505, 'min': 0.70588058} # lost: 0
limits['SH_cis/GC/n2_z/99.99'] = {'max': 0.99990505, 'min': 0.70588058} # lost: 0
limits['SH_cis/GC/nn_ang_norm/100.00'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['SH_cis/GC/nn_ang_norm/95.00'] = {'max': 45.417096999189667, 'min': 0.58047179082402589} # lost: 2
limits['SH_cis/GC/nn_ang_norm/99.00'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['SH_cis/GC/nn_ang_norm/99.50'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['SH_cis/GC/nn_ang_norm/99.90'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['SH_cis/GC/nn_ang_norm/99.99'] = {'max': 45.453689737668007, 'min': 0.58047179082402589} # lost: 0
limits['SH_cis/GC/rot_ang/100.00'] = {'max': 48.413509419152476, 'min': -45.187622158585725} # lost: 0
limits['SH_cis/GC/rot_ang/95.00'] = {'max': 39.329397977236972, 'min': -45.187622158585725} # lost: 2
limits['SH_cis/GC/rot_ang/99.00'] = {'max': 48.413509419152476, 'min': -45.187622158585725} # lost: 0
limits['SH_cis/GC/rot_ang/99.50'] = {'max': 48.413509419152476, 'min': -45.187622158585725} # lost: 0
limits['SH_cis/GC/rot_ang/99.90'] = {'max': 48.413509419152476, 'min': -45.187622158585725} # lost: 0
limits['SH_cis/GC/rot_ang/99.99'] = {'max': 48.413509419152476, 'min': -45.187622158585725} # lost: 0
limits['SH_cis/GG/dist/100.00'] = {'max': 8.1059578813363764, 'min': 6.2290357474088687} # lost: 0
limits['SH_cis/GG/dist/95.00'] = {'max': 7.8840385669808422, 'min': 6.5488126856729538} # lost: 15
limits['SH_cis/GG/dist/99.00'] = {'max': 7.9610796667539905, 'min': 6.3940597710621407} # lost: 3
limits['SH_cis/GG/dist/99.50'] = {'max': 8.088890000545172, 'min': 6.2290357474088687} # lost: 1
limits['SH_cis/GG/dist/99.90'] = {'max': 8.1059578813363764, 'min': 6.2290357474088687} # lost: 0
limits['SH_cis/GG/dist/99.99'] = {'max': 8.1059578813363764, 'min': 6.2290357474088687} # lost: 0
limits['SH_cis/GG/min_dist/100.00'] = {'max': 2.5668180520816581, 'min': 1.5243286319635456} # lost: 0
limits['SH_cis/GG/min_dist/95.00'] = {'max': 2.4780702648054747, 'min': 1.6964002303772527} # lost: 15
limits['SH_cis/GG/min_dist/99.00'] = {'max': 2.5423276746733721, 'min': 1.6308419339482774} # lost: 3
limits['SH_cis/GG/min_dist/99.50'] = {'max': 2.5489880913953749, 'min': 1.5243286319635456} # lost: 1
limits['SH_cis/GG/min_dist/99.90'] = {'max': 2.5668180520816581, 'min': 1.5243286319635456} # lost: 0
limits['SH_cis/GG/min_dist/99.99'] = {'max': 2.5668180520816581, 'min': 1.5243286319635456} # lost: 0
limits['SH_cis/GG/n2_z/100.00'] = {'max': 0.99084234, 'min': 0.44886306} # lost: 0
limits['SH_cis/GG/n2_z/95.00'] = {'max': 0.99084234, 'min': 0.63993615} # lost: 15
limits['SH_cis/GG/n2_z/99.00'] = {'max': 0.99084234, 'min': 0.51485133} # lost: 3
limits['SH_cis/GG/n2_z/99.50'] = {'max': 0.99084234, 'min': 0.49160919} # lost: 1
limits['SH_cis/GG/n2_z/99.90'] = {'max': 0.99084234, 'min': 0.44886306} # lost: 0
limits['SH_cis/GG/n2_z/99.99'] = {'max': 0.99084234, 'min': 0.44886306} # lost: 0
limits['SH_cis/GG/nn_ang_norm/100.00'] = {'max': 63.985683427732184, 'min': 7.511727643511426} # lost: 0
limits['SH_cis/GG/nn_ang_norm/95.00'] = {'max': 50.015590159792453, 'min': 7.511727643511426} # lost: 15
limits['SH_cis/GG/nn_ang_norm/99.00'] = {'max': 59.293507392473501, 'min': 7.511727643511426} # lost: 3
limits['SH_cis/GG/nn_ang_norm/99.50'] = {'max': 60.59818963716183, 'min': 7.511727643511426} # lost: 1
limits['SH_cis/GG/nn_ang_norm/99.90'] = {'max': 63.985683427732184, 'min': 7.511727643511426} # lost: 0
limits['SH_cis/GG/nn_ang_norm/99.99'] = {'max': 63.985683427732184, 'min': 7.511727643511426} # lost: 0
limits['SH_cis/GG/rot_ang/100.00'] = {'max': 58.037356178428325, 'min': -79.852956904005779} # lost: 0
limits['SH_cis/GG/rot_ang/95.00'] = {'max': 53.32209417102986, 'min': -63.793925544706617} # lost: 15
limits['SH_cis/GG/rot_ang/99.00'] = {'max': 56.788606403012572, 'min': -69.760681245241557} # lost: 3
limits['SH_cis/GG/rot_ang/99.50'] = {'max': 57.571247195797646, 'min': -79.852956904005779} # lost: 1
limits['SH_cis/GG/rot_ang/99.90'] = {'max': 58.037356178428325, 'min': -79.852956904005779} # lost: 0
limits['SH_cis/GG/rot_ang/99.99'] = {'max': 58.037356178428325, 'min': -79.852956904005779} # lost: 0
limits['SH_cis/GU/dist/100.00'] = {'max': 7.9376564435433812, 'min': 5.5260246994208986} # lost: 0
limits['SH_cis/GU/dist/95.00'] = {'max': 7.4011515254815166, 'min': 5.9684496567097547} # lost: 168
limits['SH_cis/GU/dist/99.00'] = {'max': 7.7161663681277899, 'min': 5.774782601048793} # lost: 33
limits['SH_cis/GU/dist/99.50'] = {'max': 7.7663052653450686, 'min': 5.7256345901036658} # lost: 16
limits['SH_cis/GU/dist/99.90'] = {'max': 7.8693351701554572, 'min': 5.5491606577307993} # lost: 3
limits['SH_cis/GU/dist/99.99'] = {'max': 7.9376564435433812, 'min': 5.5260246994208986} # lost: 0
limits['SH_cis/GU/min_dist/100.00'] = {'max': 3.1272867267921636, 'min': 0.9726116976753354} # lost: 0
limits['SH_cis/GU/min_dist/95.00'] = {'max': 2.487168817260812, 'min': 1.5476848446004363} # lost: 168
limits['SH_cis/GU/min_dist/99.00'] = {'max': 2.7883821257346026, 'min': 1.3976856260674861} # lost: 33
limits['SH_cis/GU/min_dist/99.50'] = {'max': 2.9687043818743026, 'min': 1.3304844643249287} # lost: 16
limits['SH_cis/GU/min_dist/99.90'] = {'max': 3.1244994853139527, 'min': 1.1565463465529229} # lost: 3
limits['SH_cis/GU/min_dist/99.99'] = {'max': 3.1272867267921636, 'min': 0.9726116976753354} # lost: 0
limits['SH_cis/GU/n2_z/100.00'] = {'max': 0.99999565, 'min': 0.44923422} # lost: 0
limits['SH_cis/GU/n2_z/95.00'] = {'max': 0.99999565, 'min': 0.76211655} # lost: 168
limits['SH_cis/GU/n2_z/99.00'] = {'max': 0.99999565, 'min': 0.63509822} # lost: 33
limits['SH_cis/GU/n2_z/99.50'] = {'max': 0.99999565, 'min': 0.54013878} # lost: 16
limits['SH_cis/GU/n2_z/99.90'] = {'max': 0.99999565, 'min': 0.468104} # lost: 3
limits['SH_cis/GU/n2_z/99.99'] = {'max': 0.99999565, 'min': 0.44923422} # lost: 0
limits['SH_cis/GU/nn_ang_norm/100.00'] = {'max': 64.357348171418423, 'min': 0.17804114037233401} # lost: 0
limits['SH_cis/GU/nn_ang_norm/95.00'] = {'max': 40.268380874523579, 'min': 0.17804114037233401} # lost: 168
limits['SH_cis/GU/nn_ang_norm/99.00'] = {'max': 50.813284537863659, 'min': 0.17804114037233401} # lost: 33
limits['SH_cis/GU/nn_ang_norm/99.50'] = {'max': 56.980620924399595, 'min': 0.17804114037233401} # lost: 16
limits['SH_cis/GU/nn_ang_norm/99.90'] = {'max': 62.760695830279566, 'min': 0.17804114037233401} # lost: 3
limits['SH_cis/GU/nn_ang_norm/99.99'] = {'max': 64.357348171418423, 'min': 0.17804114037233401} # lost: 0
limits['SH_cis/GU/rot_ang/100.00'] = {'max': 53.235990046277969, 'min': -83.73640212094142} # lost: 0
limits['SH_cis/GU/rot_ang/95.00'] = {'max': 31.621079935426994, 'min': -47.882194175549955} # lost: 168
limits['SH_cis/GU/rot_ang/99.00'] = {'max': 38.771967397830636, 'min': -64.11540447736904} # lost: 33
limits['SH_cis/GU/rot_ang/99.50'] = {'max': 43.920322527393459, 'min': -69.204515296161489} # lost: 16
limits['SH_cis/GU/rot_ang/99.90'] = {'max': 46.682161973718884, 'min': -83.67540959928462} # lost: 3
limits['SH_cis/GU/rot_ang/99.99'] = {'max': 53.235990046277969, 'min': -83.73640212094142} # lost: 0
limits['SH_cis/UA/dist/100.00'] = {'max': 8.3350646691989034, 'min': 7.0080591806791839} # lost: 0
limits['SH_cis/UA/dist/95.00'] = {'max': 8.1586119301311424, 'min': 7.28593105037986} # lost: 12
limits['SH_cis/UA/dist/99.00'] = {'max': 8.2800495599262049, 'min': 7.0214459681797035} # lost: 2
limits['SH_cis/UA/dist/99.50'] = {'max': 8.2800495599262049, 'min': 7.0080591806791839} # lost: 1
limits['SH_cis/UA/dist/99.90'] = {'max': 8.3350646691989034, 'min': 7.0080591806791839} # lost: 0
limits['SH_cis/UA/dist/99.99'] = {'max': 8.3350646691989034, 'min': 7.0080591806791839} # lost: 0
limits['SH_cis/UA/min_dist/100.00'] = {'max': 2.5106066004162257, 'min': 1.5658399736935449} # lost: 0
limits['SH_cis/UA/min_dist/95.00'] = {'max': 2.4204277766099307, 'min': 1.7741798128603585} # lost: 12
limits['SH_cis/UA/min_dist/99.00'] = {'max': 2.5088123062108809, 'min': 1.706095077338142} # lost: 2
limits['SH_cis/UA/min_dist/99.50'] = {'max': 2.5088123062108809, 'min': 1.5658399736935449} # lost: 1
limits['SH_cis/UA/min_dist/99.90'] = {'max': 2.5106066004162257, 'min': 1.5658399736935449} # lost: 0
limits['SH_cis/UA/min_dist/99.99'] = {'max': 2.5106066004162257, 'min': 1.5658399736935449} # lost: 0
limits['SH_cis/UA/n2_z/100.00'] = {'max': 0.98764145, 'min': 0.47720334} # lost: 0
limits['SH_cis/UA/n2_z/95.00'] = {'max': 0.98764145, 'min': 0.57959694} # lost: 12
limits['SH_cis/UA/n2_z/99.00'] = {'max': 0.98764145, 'min': 0.52861083} # lost: 2
limits['SH_cis/UA/n2_z/99.50'] = {'max': 0.98764145, 'min': 0.50268865} # lost: 1
limits['SH_cis/UA/n2_z/99.90'] = {'max': 0.98764145, 'min': 0.47720334} # lost: 0
limits['SH_cis/UA/n2_z/99.99'] = {'max': 0.98764145, 'min': 0.47720334} # lost: 0
limits['SH_cis/UA/nn_ang_norm/100.00'] = {'max': 61.387725354269449, 'min': 7.2266714060482364} # lost: 0
limits['SH_cis/UA/nn_ang_norm/95.00'] = {'max': 55.065145598088293, 'min': 7.2266714060482364} # lost: 12
limits['SH_cis/UA/nn_ang_norm/99.00'] = {'max': 58.218729315247806, 'min': 7.2266714060482364} # lost: 2
limits['SH_cis/UA/nn_ang_norm/99.50'] = {'max': 60.522709216644017, 'min': 7.2266714060482364} # lost: 1
limits['SH_cis/UA/nn_ang_norm/99.90'] = {'max': 61.387725354269449, 'min': 7.2266714060482364} # lost: 0
limits['SH_cis/UA/nn_ang_norm/99.99'] = {'max': 61.387725354269449, 'min': 7.2266714060482364} # lost: 0
limits['SH_cis/UA/rot_ang/100.00'] = {'max': 62.401207036455368, 'min': -49.819591683506694} # lost: 0
limits['SH_cis/UA/rot_ang/95.00'] = {'max': 56.641063369380717, 'min': -27.149982615640649} # lost: 12
limits['SH_cis/UA/rot_ang/99.00'] = {'max': 60.714473516216444, 'min': -34.700409202546567} # lost: 2
limits['SH_cis/UA/rot_ang/99.50'] = {'max': 60.714473516216444, 'min': -49.819591683506694} # lost: 1
limits['SH_cis/UA/rot_ang/99.90'] = {'max': 62.401207036455368, 'min': -49.819591683506694} # lost: 0
limits['SH_cis/UA/rot_ang/99.99'] = {'max': 62.401207036455368, 'min': -49.819591683506694} # lost: 0
limits['SH_cis/UC/dist/100.00'] = {'max': 8.1343900048538877, 'min': 6.064622536278506} # lost: 0
limits['SH_cis/UC/dist/95.00'] = {'max': 7.8773695254130658, 'min': 6.7178778908451955} # lost: 27
limits['SH_cis/UC/dist/99.00'] = {'max': 7.9700783277249743, 'min': 6.5298154136508879} # lost: 5
limits['SH_cis/UC/dist/99.50'] = {'max': 8.0602139718422219, 'min': 6.2104571241878856} # lost: 2
limits['SH_cis/UC/dist/99.90'] = {'max': 8.1343900048538877, 'min': 6.064622536278506} # lost: 0
limits['SH_cis/UC/dist/99.99'] = {'max': 8.1343900048538877, 'min': 6.064622536278506} # lost: 0
limits['SH_cis/UC/min_dist/100.00'] = {'max': 2.6816106233517405, 'min': 1.5089282971022162} # lost: 0
limits['SH_cis/UC/min_dist/95.00'] = {'max': 2.4600717393589422, 'min': 1.7027501588080207} # lost: 27
limits['SH_cis/UC/min_dist/99.00'] = {'max': 2.5450056428546564, 'min': 1.5601180590594141} # lost: 5
limits['SH_cis/UC/min_dist/99.50'] = {'max': 2.6749933840114344, 'min': 1.548593079366402} # lost: 2
limits['SH_cis/UC/min_dist/99.90'] = {'max': 2.6816106233517405, 'min': 1.5089282971022162} # lost: 0
limits['SH_cis/UC/min_dist/99.99'] = {'max': 2.6816106233517405, 'min': 1.5089282971022162} # lost: 0
limits['SH_cis/UC/n2_z/100.00'] = {'max': 0.99977386, 'min': 0.6441834} # lost: 0
limits['SH_cis/UC/n2_z/95.00'] = {'max': 0.99977386, 'min': 0.81929785} # lost: 27
limits['SH_cis/UC/n2_z/99.00'] = {'max': 0.99977386, 'min': 0.67957091} # lost: 5
limits['SH_cis/UC/n2_z/99.50'] = {'max': 0.99977386, 'min': 0.64466894} # lost: 2
limits['SH_cis/UC/n2_z/99.90'] = {'max': 0.99977386, 'min': 0.6441834} # lost: 0
limits['SH_cis/UC/n2_z/99.99'] = {'max': 0.99977386, 'min': 0.6441834} # lost: 0
limits['SH_cis/UC/nn_ang_norm/100.00'] = {'max': 50.14453730113312, 'min': 0.90655019780316504} # lost: 0
limits['SH_cis/UC/nn_ang_norm/95.00'] = {'max': 36.081065101955566, 'min': 0.90655019780316504} # lost: 27
limits['SH_cis/UC/nn_ang_norm/99.00'] = {'max': 47.170389483659015, 'min': 0.90655019780316504} # lost: 5
limits['SH_cis/UC/nn_ang_norm/99.50'] = {'max': 50.067393729552414, 'min': 0.90655019780316504} # lost: 2
limits['SH_cis/UC/nn_ang_norm/99.90'] = {'max': 50.14453730113312, 'min': 0.90655019780316504} # lost: 0
limits['SH_cis/UC/nn_ang_norm/99.99'] = {'max': 50.14453730113312, 'min': 0.90655019780316504} # lost: 0
limits['SH_cis/UC/rot_ang/100.00'] = {'max': 66.963681514582305, 'min': -52.153862303573881} # lost: 0
limits['SH_cis/UC/rot_ang/95.00'] = {'max': 56.300693377793039, 'min': -26.993170702703029} # lost: 27
limits['SH_cis/UC/rot_ang/99.00'] = {'max': 61.659390000651122, 'min': -47.074113275788761} # lost: 5
limits['SH_cis/UC/rot_ang/99.50'] = {'max': 63.937752658489849, 'min': -47.5322610887115} # lost: 2
limits['SH_cis/UC/rot_ang/99.90'] = {'max': 66.963681514582305, 'min': -52.153862303573881} # lost: 0
limits['SH_cis/UC/rot_ang/99.99'] = {'max': 66.963681514582305, 'min': -52.153862303573881} # lost: 0
limits['SH_cis/UU/dist/100.00'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['SH_cis/UU/dist/95.00'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['SH_cis/UU/dist/99.00'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['SH_cis/UU/dist/99.50'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['SH_cis/UU/dist/99.90'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['SH_cis/UU/dist/99.99'] = {'max': 7.2025468334384355, 'min': 6.6551662581604711} # lost: 0
limits['SH_cis/UU/min_dist/100.00'] = {'max': 2.5610076124600196, 'min': 2.0973615433330135} # lost: 0
limits['SH_cis/UU/min_dist/95.00'] = {'max': 2.5610076124600196, 'min': 2.0973615433330135} # lost: 0
limits['SH_cis/UU/min_dist/99.00'] = {'max': 2.5610076124600196, 'min': 2.0973615433330135} # lost: 0
limits['SH_cis/UU/min_dist/99.50'] = {'max': 2.5610076124600196, 'min': 2.0973615433330135} # lost: 0
limits['SH_cis/UU/min_dist/99.90'] = {'max': 2.5610076124600196, 'min': 2.0973615433330135} # lost: 0
limits['SH_cis/UU/min_dist/99.99'] = {'max': 2.5610076124600196, 'min': 2.0973615433330135} # lost: 0
limits['SH_cis/UU/n2_z/100.00'] = {'max': 0.96905851, 'min': 0.86458814} # lost: 0
limits['SH_cis/UU/n2_z/95.00'] = {'max': 0.96905851, 'min': 0.86458814} # lost: 0
limits['SH_cis/UU/n2_z/99.00'] = {'max': 0.96905851, 'min': 0.86458814} # lost: 0
limits['SH_cis/UU/n2_z/99.50'] = {'max': 0.96905851, 'min': 0.86458814} # lost: 0
limits['SH_cis/UU/n2_z/99.90'] = {'max': 0.96905851, 'min': 0.86458814} # lost: 0
limits['SH_cis/UU/n2_z/99.99'] = {'max': 0.96905851, 'min': 0.86458814} # lost: 0
limits['SH_cis/UU/nn_ang_norm/100.00'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['SH_cis/UU/nn_ang_norm/95.00'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['SH_cis/UU/nn_ang_norm/99.00'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['SH_cis/UU/nn_ang_norm/99.50'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['SH_cis/UU/nn_ang_norm/99.90'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['SH_cis/UU/nn_ang_norm/99.99'] = {'max': 29.197361399795764, 'min': 15.22766940546977} # lost: 0
limits['SH_cis/UU/rot_ang/100.00'] = {'max': 30.548971021250345, 'min': -30.460862012986375} # lost: 0
limits['SH_cis/UU/rot_ang/95.00'] = {'max': 30.548971021250345, 'min': -30.460862012986375} # lost: 0
limits['SH_cis/UU/rot_ang/99.00'] = {'max': 30.548971021250345, 'min': -30.460862012986375} # lost: 0
limits['SH_cis/UU/rot_ang/99.50'] = {'max': 30.548971021250345, 'min': -30.460862012986375} # lost: 0
limits['SH_cis/UU/rot_ang/99.90'] = {'max': 30.548971021250345, 'min': -30.460862012986375} # lost: 0
limits['SH_cis/UU/rot_ang/99.99'] = {'max': 30.548971021250345, 'min': -30.460862012986375} # lost: 0
limits['SH_tran/AA/dist/100.00'] = {'max': 7.1671028525189611, 'min': 5.0927797039838101} # lost: 0
limits['SH_tran/AA/dist/95.00'] = {'max': 6.9145920709158748, 'min': 5.9885366721996487} # lost: 98
limits['SH_tran/AA/dist/99.00'] = {'max': 7.0441263279077919, 'min': 5.5806501289880499} # lost: 19
limits['SH_tran/AA/dist/99.50'] = {'max': 7.0592431477028761, 'min': 5.5762623245702043} # lost: 9
limits['SH_tran/AA/dist/99.90'] = {'max': 7.1575633646428454, 'min': 5.0927797039838101} # lost: 1
limits['SH_tran/AA/dist/99.99'] = {'max': 7.1671028525189611, 'min': 5.0927797039838101} # lost: 0
limits['SH_tran/AA/min_dist/100.00'] = {'max': 2.6367609819705691, 'min': 1.0821247258247293} # lost: 0
limits['SH_tran/AA/min_dist/95.00'] = {'max': 2.4289833529438627, 'min': 1.6778960112866574} # lost: 98
limits['SH_tran/AA/min_dist/99.00'] = {'max': 2.5225259915234934, 'min': 1.5046687634631641} # lost: 19
limits['SH_tran/AA/min_dist/99.50'] = {'max': 2.5561691185893793, 'min': 1.4356734267430702} # lost: 9
limits['SH_tran/AA/min_dist/99.90'] = {'max': 2.6172518499470492, 'min': 1.0821247258247293} # lost: 1
limits['SH_tran/AA/min_dist/99.99'] = {'max': 2.6367609819705691, 'min': 1.0821247258247293} # lost: 0
limits['SH_tran/AA/n2_z/100.00'] = {'max': -0.42353752, 'min': -0.99998844} # lost: 0
limits['SH_tran/AA/n2_z/95.00'] = {'max': -0.8192333, 'min': -0.99998844} # lost: 98
limits['SH_tran/AA/n2_z/99.00'] = {'max': -0.66520482, 'min': -0.99998844} # lost: 19
limits['SH_tran/AA/n2_z/99.50'] = {'max': -0.50129378, 'min': -0.99998844} # lost: 9
limits['SH_tran/AA/n2_z/99.90'] = {'max': -0.44775712, 'min': -0.99998844} # lost: 1
limits['SH_tran/AA/n2_z/99.99'] = {'max': -0.42353752, 'min': -0.99998844} # lost: 0
limits['SH_tran/AA/nn_ang_norm/100.00'] = {'max': 64.644293069872674, 'min': 0.30646557910213801} # lost: 0
limits['SH_tran/AA/nn_ang_norm/95.00'] = {'max': 34.793839226924035, 'min': 0.30646557910213801} # lost: 98
limits['SH_tran/AA/nn_ang_norm/99.00'] = {'max': 46.549687618783196, 'min': 0.30646557910213801} # lost: 19
limits['SH_tran/AA/nn_ang_norm/99.50'] = {'max': 60.416119105689631, 'min': 0.30646557910213801} # lost: 9
limits['SH_tran/AA/nn_ang_norm/99.90'] = {'max': 62.973861025319323, 'min': 0.30646557910213801} # lost: 1
limits['SH_tran/AA/nn_ang_norm/99.99'] = {'max': 64.644293069872674, 'min': 0.30646557910213801} # lost: 0
limits['SH_tran/AA/rot_ang/100.00'] = {'max': 129.16743006334653, 'min': 58.052005626034969} # lost: 0
limits['SH_tran/AA/rot_ang/95.00'] = {'max': 104.27278543416577, 'min': 70.055964632869305} # lost: 98
limits['SH_tran/AA/rot_ang/99.00'] = {'max': 115.52407563664669, 'min': 66.444754628122539} # lost: 19
limits['SH_tran/AA/rot_ang/99.50'] = {'max': 116.81109915104528, 'min': 65.561572293033166} # lost: 9
limits['SH_tran/AA/rot_ang/99.90'] = {'max': 125.90281597509717, 'min': 58.052005626034969} # lost: 1
limits['SH_tran/AA/rot_ang/99.99'] = {'max': 129.16743006334653, 'min': 58.052005626034969} # lost: 0
limits['SH_tran/AC/dist/100.00'] = {'max': 7.0860374240275323, 'min': 5.3903740498326433} # lost: 0
limits['SH_tran/AC/dist/95.00'] = {'max': 6.8379551695960803, 'min': 5.7628109417665865} # lost: 18
limits['SH_tran/AC/dist/99.00'] = {'max': 6.9302750870643823, 'min': 5.7107372454699199} # lost: 3
limits['SH_tran/AC/dist/99.50'] = {'max': 7.007251928428575, 'min': 5.3903740498326433} # lost: 1
limits['SH_tran/AC/dist/99.90'] = {'max': 7.0860374240275323, 'min': 5.3903740498326433} # lost: 0
limits['SH_tran/AC/dist/99.99'] = {'max': 7.0860374240275323, 'min': 5.3903740498326433} # lost: 0
limits['SH_tran/AC/min_dist/100.00'] = {'max': 2.6813671663653085, 'min': 1.3317376701105483} # lost: 0
limits['SH_tran/AC/min_dist/95.00'] = {'max': 2.3578149838491136, 'min': 1.5452196622404535} # lost: 18
limits['SH_tran/AC/min_dist/99.00'] = {'max': 2.4760865865445054, 'min': 1.3746325858412505} # lost: 3
limits['SH_tran/AC/min_dist/99.50'] = {'max': 2.4947966242978921, 'min': 1.3317376701105483} # lost: 1
limits['SH_tran/AC/min_dist/99.90'] = {'max': 2.6813671663653085, 'min': 1.3317376701105483} # lost: 0
limits['SH_tran/AC/min_dist/99.99'] = {'max': 2.6813671663653085, 'min': 1.3317376701105483} # lost: 0
limits['SH_tran/AC/n2_z/100.00'] = {'max': -0.50197506, 'min': -0.99942386} # lost: 0
limits['SH_tran/AC/n2_z/95.00'] = {'max': -0.80532271, 'min': -0.99942386} # lost: 18
limits['SH_tran/AC/n2_z/99.00'] = {'max': -0.60777819, 'min': -0.99942386} # lost: 3
limits['SH_tran/AC/n2_z/99.50'] = {'max': -0.59582645, 'min': -0.99942386} # lost: 1
limits['SH_tran/AC/n2_z/99.90'] = {'max': -0.50197506, 'min': -0.99942386} # lost: 0
limits['SH_tran/AC/n2_z/99.99'] = {'max': -0.50197506, 'min': -0.99942386} # lost: 0
limits['SH_tran/AC/nn_ang_norm/100.00'] = {'max': 63.845939578546563, 'min': 1.8220982163063013} # lost: 0
limits['SH_tran/AC/nn_ang_norm/95.00'] = {'max': 36.022439994447609, 'min': 1.8220982163063013} # lost: 18
limits['SH_tran/AC/nn_ang_norm/99.00'] = {'max': 52.366194753696007, 'min': 1.8220982163063013} # lost: 3
limits['SH_tran/AC/nn_ang_norm/99.50'] = {'max': 56.815202394123887, 'min': 1.8220982163063013} # lost: 1
limits['SH_tran/AC/nn_ang_norm/99.90'] = {'max': 63.845939578546563, 'min': 1.8220982163063013} # lost: 0
limits['SH_tran/AC/nn_ang_norm/99.99'] = {'max': 63.845939578546563, 'min': 1.8220982163063013} # lost: 0
limits['SH_tran/AC/rot_ang/100.00'] = {'max': 124.91493373583866, 'min': 53.437516836942706} # lost: 0
limits['SH_tran/AC/rot_ang/95.00'] = {'max': 97.376584030427679, 'min': 55.560685799665059} # lost: 18
limits['SH_tran/AC/rot_ang/99.00'] = {'max': 103.40425605680193, 'min': 53.865301504813033} # lost: 3
limits['SH_tran/AC/rot_ang/99.50'] = {'max': 104.09440575337749, 'min': 53.437516836942706} # lost: 1
limits['SH_tran/AC/rot_ang/99.90'] = {'max': 124.91493373583866, 'min': 53.437516836942706} # lost: 0
limits['SH_tran/AC/rot_ang/99.99'] = {'max': 124.91493373583866, 'min': 53.437516836942706} # lost: 0
limits['SH_tran/AG/dist/100.00'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['SH_tran/AG/dist/95.00'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['SH_tran/AG/dist/99.00'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['SH_tran/AG/dist/99.50'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['SH_tran/AG/dist/99.90'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['SH_tran/AG/dist/99.99'] = {'max': 6.7068229069806735, 'min': 6.7068229069806735} # lost: 0
limits['SH_tran/AG/min_dist/100.00'] = {'max': 2.8707415296152785, 'min': 2.8707415296152785} # lost: 0
limits['SH_tran/AG/min_dist/95.00'] = {'max': 2.8707415296152785, 'min': 2.8707415296152785} # lost: 0
limits['SH_tran/AG/min_dist/99.00'] = {'max': 2.8707415296152785, 'min': 2.8707415296152785} # lost: 0
limits['SH_tran/AG/min_dist/99.50'] = {'max': 2.8707415296152785, 'min': 2.8707415296152785} # lost: 0
limits['SH_tran/AG/min_dist/99.90'] = {'max': 2.8707415296152785, 'min': 2.8707415296152785} # lost: 0
limits['SH_tran/AG/min_dist/99.99'] = {'max': 2.8707415296152785, 'min': 2.8707415296152785} # lost: 0
limits['SH_tran/AG/n2_z/100.00'] = {'max': -0.99937367, 'min': -0.99937367} # lost: 0
limits['SH_tran/AG/n2_z/95.00'] = {'max': -0.99937367, 'min': -0.99937367} # lost: 0
limits['SH_tran/AG/n2_z/99.00'] = {'max': -0.99937367, 'min': -0.99937367} # lost: 0
limits['SH_tran/AG/n2_z/99.50'] = {'max': -0.99937367, 'min': -0.99937367} # lost: 0
limits['SH_tran/AG/n2_z/99.90'] = {'max': -0.99937367, 'min': -0.99937367} # lost: 0
limits['SH_tran/AG/n2_z/99.99'] = {'max': -0.99937367, 'min': -0.99937367} # lost: 0
limits['SH_tran/AG/nn_ang_norm/100.00'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['SH_tran/AG/nn_ang_norm/95.00'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['SH_tran/AG/nn_ang_norm/99.00'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['SH_tran/AG/nn_ang_norm/99.50'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['SH_tran/AG/nn_ang_norm/99.90'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['SH_tran/AG/nn_ang_norm/99.99'] = {'max': 1.9308758090279241, 'min': 1.9308758090279241} # lost: 0
limits['SH_tran/AG/rot_ang/100.00'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['SH_tran/AG/rot_ang/95.00'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['SH_tran/AG/rot_ang/99.00'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['SH_tran/AG/rot_ang/99.50'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['SH_tran/AG/rot_ang/99.90'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['SH_tran/AG/rot_ang/99.99'] = {'max': 78.952406494502128, 'min': 78.952406494502128} # lost: 0
limits['SH_tran/AU/dist/100.00'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['SH_tran/AU/dist/95.00'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['SH_tran/AU/dist/99.00'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['SH_tran/AU/dist/99.50'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['SH_tran/AU/dist/99.90'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['SH_tran/AU/dist/99.99'] = {'max': 6.8006510151678841, 'min': 6.8006510151678841} # lost: 0
limits['SH_tran/AU/min_dist/100.00'] = {'max': 2.5563863206634445, 'min': 2.5563863206634445} # lost: 0
limits['SH_tran/AU/min_dist/95.00'] = {'max': 2.5563863206634445, 'min': 2.5563863206634445} # lost: 0
limits['SH_tran/AU/min_dist/99.00'] = {'max': 2.5563863206634445, 'min': 2.5563863206634445} # lost: 0
limits['SH_tran/AU/min_dist/99.50'] = {'max': 2.5563863206634445, 'min': 2.5563863206634445} # lost: 0
limits['SH_tran/AU/min_dist/99.90'] = {'max': 2.5563863206634445, 'min': 2.5563863206634445} # lost: 0
limits['SH_tran/AU/min_dist/99.99'] = {'max': 2.5563863206634445, 'min': 2.5563863206634445} # lost: 0
limits['SH_tran/AU/n2_z/100.00'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['SH_tran/AU/n2_z/95.00'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['SH_tran/AU/n2_z/99.00'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['SH_tran/AU/n2_z/99.50'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['SH_tran/AU/n2_z/99.90'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['SH_tran/AU/n2_z/99.99'] = {'max': -0.99604452, 'min': -0.99604452} # lost: 0
limits['SH_tran/AU/nn_ang_norm/100.00'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['SH_tran/AU/nn_ang_norm/95.00'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['SH_tran/AU/nn_ang_norm/99.00'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['SH_tran/AU/nn_ang_norm/99.50'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['SH_tran/AU/nn_ang_norm/99.90'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['SH_tran/AU/nn_ang_norm/99.99'] = {'max': 6.0773743711159511, 'min': 6.0773743711159511} # lost: 0
limits['SH_tran/AU/rot_ang/100.00'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['SH_tran/AU/rot_ang/95.00'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['SH_tran/AU/rot_ang/99.00'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['SH_tran/AU/rot_ang/99.50'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['SH_tran/AU/rot_ang/99.90'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['SH_tran/AU/rot_ang/99.99'] = {'max': 95.984545493513778, 'min': 95.984545493513778} # lost: 0
limits['SH_tran/CA/dist/100.00'] = {'max': 8.2554230507350219, 'min': 6.7296936773893785} # lost: 0
limits['SH_tran/CA/dist/95.00'] = {'max': 8.1212033051294696, 'min': 7.0657401192186553} # lost: 23
limits['SH_tran/CA/dist/99.00'] = {'max': 8.1946639258618266, 'min': 6.8290733310488196} # lost: 4
limits['SH_tran/CA/dist/99.50'] = {'max': 8.1992888908513386, 'min': 6.7691149430985025} # lost: 2
limits['SH_tran/CA/dist/99.90'] = {'max': 8.2554230507350219, 'min': 6.7296936773893785} # lost: 0
limits['SH_tran/CA/dist/99.99'] = {'max': 8.2554230507350219, 'min': 6.7296936773893785} # lost: 0
limits['SH_tran/CA/min_dist/100.00'] = {'max': 2.4488093455635429, 'min': 0.81495921426421836} # lost: 0
limits['SH_tran/CA/min_dist/95.00'] = {'max': 2.3874721450019902, 'min': 1.4470987466948395} # lost: 23
limits['SH_tran/CA/min_dist/99.00'] = {'max': 2.4388046192085233, 'min': 1.2486908425605494} # lost: 4
limits['SH_tran/CA/min_dist/99.50'] = {'max': 2.4432871730199204, 'min': 1.1468313979028599} # lost: 2
limits['SH_tran/CA/min_dist/99.90'] = {'max': 2.4488093455635429, 'min': 0.81495921426421836} # lost: 0
limits['SH_tran/CA/min_dist/99.99'] = {'max': 2.4488093455635429, 'min': 0.81495921426421836} # lost: 0
limits['SH_tran/CA/n2_z/100.00'] = {'max': -0.61956173, 'min': -0.99949104} # lost: 0
limits['SH_tran/CA/n2_z/95.00'] = {'max': -0.83339095, 'min': -0.99949104} # lost: 23
limits['SH_tran/CA/n2_z/99.00'] = {'max': -0.62018818, 'min': -0.99949104} # lost: 4
limits['SH_tran/CA/n2_z/99.50'] = {'max': -0.61987025, 'min': -0.99949104} # lost: 2
limits['SH_tran/CA/n2_z/99.90'] = {'max': -0.61956173, 'min': -0.99949104} # lost: 0
limits['SH_tran/CA/n2_z/99.99'] = {'max': -0.61956173, 'min': -0.99949104} # lost: 0
limits['SH_tran/CA/nn_ang_norm/100.00'] = {'max': 52.070324619229396, 'min': 0.71381806120169244} # lost: 0
limits['SH_tran/CA/nn_ang_norm/95.00'] = {'max': 34.103361743349126, 'min': 0.71381806120169244} # lost: 23
limits['SH_tran/CA/nn_ang_norm/99.00'] = {'max': 51.963473139853704, 'min': 0.71381806120169244} # lost: 4
limits['SH_tran/CA/nn_ang_norm/99.50'] = {'max': 52.040831862393276, 'min': 0.71381806120169244} # lost: 2
limits['SH_tran/CA/nn_ang_norm/99.90'] = {'max': 52.070324619229396, 'min': 0.71381806120169244} # lost: 0
limits['SH_tran/CA/nn_ang_norm/99.99'] = {'max': 52.070324619229396, 'min': 0.71381806120169244} # lost: 0
limits['SH_tran/CA/rot_ang/100.00'] = {'max': 126.27785125129137, 'min': 66.172985588877609} # lost: 0
limits['SH_tran/CA/rot_ang/95.00'] = {'max': 106.79333461857797, 'min': 74.206592063654938} # lost: 23
limits['SH_tran/CA/rot_ang/99.00'] = {'max': 118.78450166679744, 'min': 71.59060149916796} # lost: 4
limits['SH_tran/CA/rot_ang/99.50'] = {'max': 126.07140013964012, 'min': 70.947238413638871} # lost: 2
limits['SH_tran/CA/rot_ang/99.90'] = {'max': 126.27785125129137, 'min': 66.172985588877609} # lost: 0
limits['SH_tran/CA/rot_ang/99.99'] = {'max': 126.27785125129137, 'min': 66.172985588877609} # lost: 0
limits['SH_tran/CC/dist/100.00'] = {'max': 7.8000180232569649, 'min': 6.4662881728779986} # lost: 0
limits['SH_tran/CC/dist/95.00'] = {'max': 7.535213800717564, 'min': 6.7069092818332896} # lost: 20
limits['SH_tran/CC/dist/99.00'] = {'max': 7.6733537101119502, 'min': 6.5011642213960474} # lost: 4
limits['SH_tran/CC/dist/99.50'] = {'max': 7.7299508504012922, 'min': 6.4985434761815082} # lost: 2
limits['SH_tran/CC/dist/99.90'] = {'max': 7.8000180232569649, 'min': 6.4662881728779986} # lost: 0
limits['SH_tran/CC/dist/99.99'] = {'max': 7.8000180232569649, 'min': 6.4662881728779986} # lost: 0
limits['SH_tran/CC/min_dist/100.00'] = {'max': 2.3805787071163236, 'min': 1.2975910774692407} # lost: 0
limits['SH_tran/CC/min_dist/95.00'] = {'max': 2.2651484794591159, 'min': 1.4251281096611461} # lost: 20
limits['SH_tran/CC/min_dist/99.00'] = {'max': 2.3687159126685717, 'min': 1.3226131143344337} # lost: 4
limits['SH_tran/CC/min_dist/99.50'] = {'max': 2.3752745195727489, 'min': 1.3220665857240392} # lost: 2
limits['SH_tran/CC/min_dist/99.90'] = {'max': 2.3805787071163236, 'min': 1.2975910774692407} # lost: 0
limits['SH_tran/CC/min_dist/99.99'] = {'max': 2.3805787071163236, 'min': 1.2975910774692407} # lost: 0
limits['SH_tran/CC/n2_z/100.00'] = {'max': -0.45358694, 'min': -0.99692291} # lost: 0
limits['SH_tran/CC/n2_z/95.00'] = {'max': -0.769243, 'min': -0.99692291} # lost: 20
limits['SH_tran/CC/n2_z/99.00'] = {'max': -0.73030925, 'min': -0.99692291} # lost: 4
limits['SH_tran/CC/n2_z/99.50'] = {'max': -0.66636229, 'min': -0.99692291} # lost: 2
limits['SH_tran/CC/n2_z/99.90'] = {'max': -0.45358694, 'min': -0.99692291} # lost: 0
limits['SH_tran/CC/n2_z/99.99'] = {'max': -0.45358694, 'min': -0.99692291} # lost: 0
limits['SH_tran/CC/nn_ang_norm/100.00'] = {'max': 63.10090254388156, 'min': 4.1244047213558588} # lost: 0
limits['SH_tran/CC/nn_ang_norm/95.00'] = {'max': 39.378275858214948, 'min': 4.1244047213558588} # lost: 20
limits['SH_tran/CC/nn_ang_norm/99.00'] = {'max': 43.928739128574193, 'min': 4.1244047213558588} # lost: 4
limits['SH_tran/CC/nn_ang_norm/99.50'] = {'max': 45.917977082827036, 'min': 4.1244047213558588} # lost: 2
limits['SH_tran/CC/nn_ang_norm/99.90'] = {'max': 63.10090254388156, 'min': 4.1244047213558588} # lost: 0
limits['SH_tran/CC/nn_ang_norm/99.99'] = {'max': 63.10090254388156, 'min': 4.1244047213558588} # lost: 0
limits['SH_tran/CC/rot_ang/100.00'] = {'max': 120.89914749690053, 'min': 69.703072148763411} # lost: 0
limits['SH_tran/CC/rot_ang/95.00'] = {'max': 108.05802331532291, 'min': 75.560416394652123} # lost: 20
limits['SH_tran/CC/rot_ang/99.00'] = {'max': 110.76693845616121, 'min': 70.844404414336111} # lost: 4
limits['SH_tran/CC/rot_ang/99.50'] = {'max': 111.84122545066828, 'min': 69.85730862363981} # lost: 2
limits['SH_tran/CC/rot_ang/99.90'] = {'max': 120.89914749690053, 'min': 69.703072148763411} # lost: 0
limits['SH_tran/CC/rot_ang/99.99'] = {'max': 120.89914749690053, 'min': 69.703072148763411} # lost: 0
limits['SH_tran/CG/dist/100.00'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['SH_tran/CG/dist/95.00'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['SH_tran/CG/dist/99.00'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['SH_tran/CG/dist/99.50'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['SH_tran/CG/dist/99.90'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['SH_tran/CG/dist/99.99'] = {'max': 7.7020918665510099, 'min': 7.7020918665510099} # lost: 0
limits['SH_tran/CG/min_dist/100.00'] = {'max': 2.9387283346799098, 'min': 2.9387283346799098} # lost: 0
limits['SH_tran/CG/min_dist/95.00'] = {'max': 2.9387283346799098, 'min': 2.9387283346799098} # lost: 0
limits['SH_tran/CG/min_dist/99.00'] = {'max': 2.9387283346799098, 'min': 2.9387283346799098} # lost: 0
limits['SH_tran/CG/min_dist/99.50'] = {'max': 2.9387283346799098, 'min': 2.9387283346799098} # lost: 0
limits['SH_tran/CG/min_dist/99.90'] = {'max': 2.9387283346799098, 'min': 2.9387283346799098} # lost: 0
limits['SH_tran/CG/min_dist/99.99'] = {'max': 2.9387283346799098, 'min': 2.9387283346799098} # lost: 0
limits['SH_tran/CG/n2_z/100.00'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['SH_tran/CG/n2_z/95.00'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['SH_tran/CG/n2_z/99.00'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['SH_tran/CG/n2_z/99.50'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['SH_tran/CG/n2_z/99.90'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['SH_tran/CG/n2_z/99.99'] = {'max': -0.99974322, 'min': -0.99974322} # lost: 0
limits['SH_tran/CG/nn_ang_norm/100.00'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['SH_tran/CG/nn_ang_norm/95.00'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['SH_tran/CG/nn_ang_norm/99.00'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['SH_tran/CG/nn_ang_norm/99.50'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['SH_tran/CG/nn_ang_norm/99.90'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['SH_tran/CG/nn_ang_norm/99.99'] = {'max': 1.9605461507824771, 'min': 1.9605461507824771} # lost: 0
limits['SH_tran/CG/rot_ang/100.00'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['SH_tran/CG/rot_ang/95.00'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['SH_tran/CG/rot_ang/99.00'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['SH_tran/CG/rot_ang/99.50'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['SH_tran/CG/rot_ang/99.90'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['SH_tran/CG/rot_ang/99.99'] = {'max': 88.957961424973675, 'min': 88.957961424973675} # lost: 0
limits['SH_tran/CU/dist/100.00'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['SH_tran/CU/dist/95.00'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['SH_tran/CU/dist/99.00'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['SH_tran/CU/dist/99.50'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['SH_tran/CU/dist/99.90'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['SH_tran/CU/dist/99.99'] = {'max': 7.5032566901665252, 'min': 7.5032566901665252} # lost: 0
limits['SH_tran/CU/min_dist/100.00'] = {'max': 2.8154607921925181, 'min': 2.8154607921925181} # lost: 0
limits['SH_tran/CU/min_dist/95.00'] = {'max': 2.8154607921925181, 'min': 2.8154607921925181} # lost: 0
limits['SH_tran/CU/min_dist/99.00'] = {'max': 2.8154607921925181, 'min': 2.8154607921925181} # lost: 0
limits['SH_tran/CU/min_dist/99.50'] = {'max': 2.8154607921925181, 'min': 2.8154607921925181} # lost: 0
limits['SH_tran/CU/min_dist/99.90'] = {'max': 2.8154607921925181, 'min': 2.8154607921925181} # lost: 0
limits['SH_tran/CU/min_dist/99.99'] = {'max': 2.8154607921925181, 'min': 2.8154607921925181} # lost: 0
limits['SH_tran/CU/n2_z/100.00'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['SH_tran/CU/n2_z/95.00'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['SH_tran/CU/n2_z/99.00'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['SH_tran/CU/n2_z/99.50'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['SH_tran/CU/n2_z/99.90'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['SH_tran/CU/n2_z/99.99'] = {'max': -0.99973744, 'min': -0.99973744} # lost: 0
limits['SH_tran/CU/nn_ang_norm/100.00'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['SH_tran/CU/nn_ang_norm/95.00'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['SH_tran/CU/nn_ang_norm/99.00'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['SH_tran/CU/nn_ang_norm/99.50'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['SH_tran/CU/nn_ang_norm/99.90'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['SH_tran/CU/nn_ang_norm/99.99'] = {'max': 3.0641407961164475, 'min': 3.0641407961164475} # lost: 0
limits['SH_tran/CU/rot_ang/100.00'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['SH_tran/CU/rot_ang/95.00'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['SH_tran/CU/rot_ang/99.00'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['SH_tran/CU/rot_ang/99.50'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['SH_tran/CU/rot_ang/99.90'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['SH_tran/CU/rot_ang/99.99'] = {'max': 103.98906283787686, 'min': 103.98906283787686} # lost: 0
limits['SH_tran/GA/dist/100.00'] = {'max': 7.9993818993440335, 'min': 5.7386259561977395} # lost: 0
limits['SH_tran/GA/dist/95.00'] = {'max': 7.4540077116190391, 'min': 6.3821109694574023} # lost: 1382
limits['SH_tran/GA/dist/99.00'] = {'max': 7.6768173181530308, 'min': 6.1940544749712574} # lost: 276
limits['SH_tran/GA/dist/99.50'] = {'max': 7.7496334726172638, 'min': 6.1183513129160421} # lost: 138
limits['SH_tran/GA/dist/99.90'] = {'max': 7.8569083375242341, 'min': 5.9644625260513173} # lost: 27
limits['SH_tran/GA/dist/99.99'] = {'max': 7.9821662050474478, 'min': 5.8201211122567535} # lost: 2
limits['SH_tran/GA/min_dist/100.00'] = {'max': 3.0838088257631671, 'min': 0.59678931577837047} # lost: 0
limits['SH_tran/GA/min_dist/95.00'] = {'max': 2.4500130674559468, 'min': 1.5565579233798152} # lost: 1382
limits['SH_tran/GA/min_dist/99.00'] = {'max': 2.5982336805128674, 'min': 1.2761565664578516} # lost: 276
limits['SH_tran/GA/min_dist/99.50'] = {'max': 2.6660861044291058, 'min': 1.1297625673907115} # lost: 138
limits['SH_tran/GA/min_dist/99.90'] = {'max': 2.8055530607169219, 'min': 0.8376199818700224} # lost: 27
limits['SH_tran/GA/min_dist/99.99'] = {'max': 3.0419418021090485, 'min': 0.66668583071191057} # lost: 2
limits['SH_tran/GA/n2_z/100.00'] = {'max': -0.41874087, 'min': -1.0} # lost: 0
limits['SH_tran/GA/n2_z/95.00'] = {'max': -0.76135945, 'min': -1.0} # lost: 1382
limits['SH_tran/GA/n2_z/99.00'] = {'max': -0.62581819, 'min': -1.0} # lost: 276
limits['SH_tran/GA/n2_z/99.50'] = {'max': -0.58516836, 'min': -1.0} # lost: 138
limits['SH_tran/GA/n2_z/99.90'] = {'max': -0.47813526, 'min': -1.0} # lost: 27
limits['SH_tran/GA/n2_z/99.99'] = {'max': -0.42876455, 'min': -1.0} # lost: 2
limits['SH_tran/GA/nn_ang_norm/100.00'] = {'max': 64.713387263516523, 'min': 0.0} # lost: 0
limits['SH_tran/GA/nn_ang_norm/95.00'] = {'max': 40.548273602659776, 'min': 0.0} # lost: 1382
limits['SH_tran/GA/nn_ang_norm/99.00'] = {'max': 51.659475080274774, 'min': 0.0} # lost: 276
limits['SH_tran/GA/nn_ang_norm/99.50'] = {'max': 54.412164259194981, 'min': 0.0} # lost: 138
limits['SH_tran/GA/nn_ang_norm/99.90'] = {'max': 61.773578222094642, 'min': 0.0} # lost: 27
limits['SH_tran/GA/nn_ang_norm/99.99'] = {'max': 64.582657442802471, 'min': 0.0} # lost: 2
limits['SH_tran/GA/rot_ang/100.00'] = {'max': 133.92411287488474, 'min': 44.463742261038476} # lost: 0
limits['SH_tran/GA/rot_ang/95.00'] = {'max': 95.421527075651554, 'min': 63.21935034972784} # lost: 1382
limits['SH_tran/GA/rot_ang/99.00'] = {'max': 106.37475313709989, 'min': 57.658891977984503} # lost: 276
limits['SH_tran/GA/rot_ang/99.50'] = {'max': 109.92792295229519, 'min': 56.006216995748154} # lost: 138
limits['SH_tran/GA/rot_ang/99.90'] = {'max': 116.01901494627364, 'min': 51.434533324033517} # lost: 27
limits['SH_tran/GA/rot_ang/99.99'] = {'max': 132.94117554693284, 'min': 45.524876542170084} # lost: 2
limits['SH_tran/GC/dist/100.00'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['SH_tran/GC/dist/95.00'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['SH_tran/GC/dist/99.00'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['SH_tran/GC/dist/99.50'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['SH_tran/GC/dist/99.90'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['SH_tran/GC/dist/99.99'] = {'max': 6.8793191539929444, 'min': 5.9629346547859399} # lost: 0
limits['SH_tran/GC/min_dist/100.00'] = {'max': 1.7351616776215806, 'min': 1.0813045910250982} # lost: 0
limits['SH_tran/GC/min_dist/95.00'] = {'max': 1.7351616776215806, 'min': 1.0813045910250982} # lost: 0
limits['SH_tran/GC/min_dist/99.00'] = {'max': 1.7351616776215806, 'min': 1.0813045910250982} # lost: 0
limits['SH_tran/GC/min_dist/99.50'] = {'max': 1.7351616776215806, 'min': 1.0813045910250982} # lost: 0
limits['SH_tran/GC/min_dist/99.90'] = {'max': 1.7351616776215806, 'min': 1.0813045910250982} # lost: 0
limits['SH_tran/GC/min_dist/99.99'] = {'max': 1.7351616776215806, 'min': 1.0813045910250982} # lost: 0
limits['SH_tran/GC/n2_z/100.00'] = {'max': -0.47715172, 'min': -0.99881917} # lost: 0
limits['SH_tran/GC/n2_z/95.00'] = {'max': -0.47715172, 'min': -0.99881917} # lost: 0
limits['SH_tran/GC/n2_z/99.00'] = {'max': -0.47715172, 'min': -0.99881917} # lost: 0
limits['SH_tran/GC/n2_z/99.50'] = {'max': -0.47715172, 'min': -0.99881917} # lost: 0
limits['SH_tran/GC/n2_z/99.90'] = {'max': -0.47715172, 'min': -0.99881917} # lost: 0
limits['SH_tran/GC/n2_z/99.99'] = {'max': -0.47715172, 'min': -0.99881917} # lost: 0
limits['SH_tran/GC/nn_ang_norm/100.00'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['SH_tran/GC/nn_ang_norm/95.00'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['SH_tran/GC/nn_ang_norm/99.00'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['SH_tran/GC/nn_ang_norm/99.50'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['SH_tran/GC/nn_ang_norm/99.90'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['SH_tran/GC/nn_ang_norm/99.99'] = {'max': 62.173212590432101, 'min': 2.6064634802122271} # lost: 0
limits['SH_tran/GC/rot_ang/100.00'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['SH_tran/GC/rot_ang/95.00'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['SH_tran/GC/rot_ang/99.00'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['SH_tran/GC/rot_ang/99.50'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['SH_tran/GC/rot_ang/99.90'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['SH_tran/GC/rot_ang/99.99'] = {'max': 98.165661461234478, 'min': 66.324754855574753} # lost: 0
limits['SH_tran/GG/dist/100.00'] = {'max': 8.1931136970471581, 'min': 6.277946328901379} # lost: 0
limits['SH_tran/GG/dist/95.00'] = {'max': 7.7899810548276465, 'min': 6.6329068668250963} # lost: 56
limits['SH_tran/GG/dist/99.00'] = {'max': 7.9479992081015354, 'min': 6.4396007132297104} # lost: 11
limits['SH_tran/GG/dist/99.50'] = {'max': 8.0183345994110056, 'min': 6.3721044562883851} # lost: 5
limits['SH_tran/GG/dist/99.90'] = {'max': 8.1223310129372432, 'min': 6.277946328901379} # lost: 1
limits['SH_tran/GG/dist/99.99'] = {'max': 8.1931136970471581, 'min': 6.277946328901379} # lost: 0
limits['SH_tran/GG/min_dist/100.00'] = {'max': 2.898601683119455, 'min': 1.2409810732149389} # lost: 0
limits['SH_tran/GG/min_dist/95.00'] = {'max': 2.514494239133497, 'min': 1.5297675562737474} # lost: 56
limits['SH_tran/GG/min_dist/99.00'] = {'max': 2.7486878846531848, 'min': 1.3314089096100976} # lost: 11
limits['SH_tran/GG/min_dist/99.50'] = {'max': 2.8433079295286832, 'min': 1.2808205186505028} # lost: 5
limits['SH_tran/GG/min_dist/99.90'] = {'max': 2.8912042622716116, 'min': 1.2409810732149389} # lost: 1
limits['SH_tran/GG/min_dist/99.99'] = {'max': 2.898601683119455, 'min': 1.2409810732149389} # lost: 0
limits['SH_tran/GG/n2_z/100.00'] = {'max': -0.44574144, 'min': -0.99988687} # lost: 0
limits['SH_tran/GG/n2_z/95.00'] = {'max': -0.82104731, 'min': -0.99988687} # lost: 56
limits['SH_tran/GG/n2_z/99.00'] = {'max': -0.71918333, 'min': -0.99988687} # lost: 11
limits['SH_tran/GG/n2_z/99.50'] = {'max': -0.71336907, 'min': -0.99988687} # lost: 5
limits['SH_tran/GG/n2_z/99.90'] = {'max': -0.58754492, 'min': -0.99988687} # lost: 1
limits['SH_tran/GG/n2_z/99.99'] = {'max': -0.44574144, 'min': -0.99988687} # lost: 0
limits['SH_tran/GG/nn_ang_norm/100.00'] = {'max': 63.137225489887697, 'min': 0.79892221826005994} # lost: 0
limits['SH_tran/GG/nn_ang_norm/95.00'] = {'max': 34.150244161812083, 'min': 0.79892221826005994} # lost: 56
limits['SH_tran/GG/nn_ang_norm/99.00'] = {'max': 44.326543006214081, 'min': 0.79892221826005994} # lost: 11
limits['SH_tran/GG/nn_ang_norm/99.50'] = {'max': 44.637384915341357, 'min': 0.79892221826005994} # lost: 5
limits['SH_tran/GG/nn_ang_norm/99.90'] = {'max': 54.04150355331673, 'min': 0.79892221826005994} # lost: 1
limits['SH_tran/GG/nn_ang_norm/99.99'] = {'max': 63.137225489887697, 'min': 0.79892221826005994} # lost: 0
limits['SH_tran/GG/rot_ang/100.00'] = {'max': 119.85853183721325, 'min': 60.690121418434728} # lost: 0
limits['SH_tran/GG/rot_ang/95.00'] = {'max': 104.15002334469499, 'min': 66.857235293711142} # lost: 56
limits['SH_tran/GG/rot_ang/99.00'] = {'max': 109.47634007237932, 'min': 62.984509415425151} # lost: 11
limits['SH_tran/GG/rot_ang/99.50'] = {'max': 112.46699444490473, 'min': 61.922933605663175} # lost: 5
limits['SH_tran/GG/rot_ang/99.90'] = {'max': 115.46303250878387, 'min': 60.690121418434728} # lost: 1
limits['SH_tran/GG/rot_ang/99.99'] = {'max': 119.85853183721325, 'min': 60.690121418434728} # lost: 0
limits['SH_tran/GU/dist/100.00'] = {'max': 8.0614286471138374, 'min': 6.4028904664831163} # lost: 0
limits['SH_tran/GU/dist/95.00'] = {'max': 7.6821407323726953, 'min': 6.7639074289048819} # lost: 47
limits['SH_tran/GU/dist/99.00'] = {'max': 7.8526733854304762, 'min': 6.6201424027912541} # lost: 9
limits['SH_tran/GU/dist/99.50'] = {'max': 7.9192278656518518, 'min': 6.4546538614586035} # lost: 4
limits['SH_tran/GU/dist/99.90'] = {'max': 8.0614286471138374, 'min': 6.4028904664831163} # lost: 0
limits['SH_tran/GU/dist/99.99'] = {'max': 8.0614286471138374, 'min': 6.4028904664831163} # lost: 0
limits['SH_tran/GU/min_dist/100.00'] = {'max': 2.5469900523909885, 'min': 1.1452716149215512} # lost: 0
limits['SH_tran/GU/min_dist/95.00'] = {'max': 2.3225860168346091, 'min': 1.5034750323203201} # lost: 47
limits['SH_tran/GU/min_dist/99.00'] = {'max': 2.4761795781274931, 'min': 1.3593559265769617} # lost: 9
limits['SH_tran/GU/min_dist/99.50'] = {'max': 2.4838534717182879, 'min': 1.2514209254229818} # lost: 4
limits['SH_tran/GU/min_dist/99.90'] = {'max': 2.5469900523909885, 'min': 1.1452716149215512} # lost: 0
limits['SH_tran/GU/min_dist/99.99'] = {'max': 2.5469900523909885, 'min': 1.1452716149215512} # lost: 0
limits['SH_tran/GU/n2_z/100.00'] = {'max': -0.71290326, 'min': -0.99988282} # lost: 0
limits['SH_tran/GU/n2_z/95.00'] = {'max': -0.80050695, 'min': -0.99988282} # lost: 47
limits['SH_tran/GU/n2_z/99.00'] = {'max': -0.7543025, 'min': -0.99988282} # lost: 9
limits['SH_tran/GU/n2_z/99.50'] = {'max': -0.72539341, 'min': -0.99988282} # lost: 4
limits['SH_tran/GU/n2_z/99.90'] = {'max': -0.71290326, 'min': -0.99988282} # lost: 0
limits['SH_tran/GU/n2_z/99.99'] = {'max': -0.71290326, 'min': -0.99988282} # lost: 0
limits['SH_tran/GU/nn_ang_norm/100.00'] = {'max': 44.993415356017437, 'min': 0.086232959504258133} # lost: 0
limits['SH_tran/GU/nn_ang_norm/95.00'] = {'max': 36.825205787977524, 'min': 0.086232959504258133} # lost: 47
limits['SH_tran/GU/nn_ang_norm/99.00'] = {'max': 40.506213297750833, 'min': 0.086232959504258133} # lost: 9
limits['SH_tran/GU/nn_ang_norm/99.50'] = {'max': 41.996560574647617, 'min': 0.086232959504258133} # lost: 4
limits['SH_tran/GU/nn_ang_norm/99.90'] = {'max': 44.993415356017437, 'min': 0.086232959504258133} # lost: 0
limits['SH_tran/GU/nn_ang_norm/99.99'] = {'max': 44.993415356017437, 'min': 0.086232959504258133} # lost: 0
limits['SH_tran/GU/rot_ang/100.00'] = {'max': 127.68598065177342, 'min': 48.582855550616202} # lost: 0
limits['SH_tran/GU/rot_ang/95.00'] = {'max': 104.47754635763255, 'min': 61.86811707004383} # lost: 47
limits['SH_tran/GU/rot_ang/99.00'] = {'max': 113.13102830469796, 'min': 59.001141957459005} # lost: 9
limits['SH_tran/GU/rot_ang/99.50'] = {'max': 116.41035064666964, 'min': 52.833071024690845} # lost: 4
limits['SH_tran/GU/rot_ang/99.90'] = {'max': 127.68598065177342, 'min': 48.582855550616202} # lost: 0
limits['SH_tran/GU/rot_ang/99.99'] = {'max': 127.68598065177342, 'min': 48.582855550616202} # lost: 0
limits['SH_tran/UA/dist/100.00'] = {'max': 8.2750347582988919, 'min': 6.0050976822565971} # lost: 0
limits['SH_tran/UA/dist/95.00'] = {'max': 8.0576085469828467, 'min': 6.7337653935693362} # lost: 13
limits['SH_tran/UA/dist/99.00'] = {'max': 8.2710457162776354, 'min': 6.2706303488833797} # lost: 2
limits['SH_tran/UA/dist/99.50'] = {'max': 8.2710457162776354, 'min': 6.0050976822565971} # lost: 1
limits['SH_tran/UA/dist/99.90'] = {'max': 8.2750347582988919, 'min': 6.0050976822565971} # lost: 0
limits['SH_tran/UA/dist/99.99'] = {'max': 8.2750347582988919, 'min': 6.0050976822565971} # lost: 0
limits['SH_tran/UA/min_dist/100.00'] = {'max': 2.5359430974064701, 'min': 1.1619076789359595} # lost: 0
limits['SH_tran/UA/min_dist/95.00'] = {'max': 2.351580329150579, 'min': 1.4364392869855946} # lost: 13
limits['SH_tran/UA/min_dist/99.00'] = {'max': 2.4755845687951128, 'min': 1.2776270620291457} # lost: 2
limits['SH_tran/UA/min_dist/99.50'] = {'max': 2.4755845687951128, 'min': 1.1619076789359595} # lost: 1
limits['SH_tran/UA/min_dist/99.90'] = {'max': 2.5359430974064701, 'min': 1.1619076789359595} # lost: 0
limits['SH_tran/UA/min_dist/99.99'] = {'max': 2.5359430974064701, 'min': 1.1619076789359595} # lost: 0
limits['SH_tran/UA/n2_z/100.00'] = {'max': -0.64080948, 'min': -0.99937952} # lost: 0
limits['SH_tran/UA/n2_z/95.00'] = {'max': -0.76041466, 'min': -0.99937952} # lost: 13
limits['SH_tran/UA/n2_z/99.00'] = {'max': -0.68684125, 'min': -0.99937952} # lost: 2
limits['SH_tran/UA/n2_z/99.50'] = {'max': -0.66000384, 'min': -0.99937952} # lost: 1
limits['SH_tran/UA/n2_z/99.90'] = {'max': -0.64080948, 'min': -0.99937952} # lost: 0
limits['SH_tran/UA/n2_z/99.99'] = {'max': -0.64080948, 'min': -0.99937952} # lost: 0
limits['SH_tran/UA/nn_ang_norm/100.00'] = {'max': 50.180274672103479, 'min': 2.5067153975733731} # lost: 0
limits['SH_tran/UA/nn_ang_norm/95.00'] = {'max': 39.388124990998108, 'min': 2.5067153975733731} # lost: 13
limits['SH_tran/UA/nn_ang_norm/99.00'] = {'max': 44.316202099810681, 'min': 2.5067153975733731} # lost: 2
limits['SH_tran/UA/nn_ang_norm/99.50'] = {'max': 48.891295032317004, 'min': 2.5067153975733731} # lost: 1
limits['SH_tran/UA/nn_ang_norm/99.90'] = {'max': 50.180274672103479, 'min': 2.5067153975733731} # lost: 0
limits['SH_tran/UA/nn_ang_norm/99.99'] = {'max': 50.180274672103479, 'min': 2.5067153975733731} # lost: 0
limits['SH_tran/UA/rot_ang/100.00'] = {'max': 136.37457249646712, 'min': 57.304726983707916} # lost: 0
limits['SH_tran/UA/rot_ang/95.00'] = {'max': 116.97115746871478, 'min': 60.275738681213198} # lost: 13
limits['SH_tran/UA/rot_ang/99.00'] = {'max': 126.91129422285537, 'min': 58.809061601884764} # lost: 2
limits['SH_tran/UA/rot_ang/99.50'] = {'max': 126.91129422285537, 'min': 57.304726983707916} # lost: 1
limits['SH_tran/UA/rot_ang/99.90'] = {'max': 136.37457249646712, 'min': 57.304726983707916} # lost: 0
limits['SH_tran/UA/rot_ang/99.99'] = {'max': 136.37457249646712, 'min': 57.304726983707916} # lost: 0
limits['SH_tran/UC/dist/100.00'] = {'max': 7.8021266423362592, 'min': 6.4523862439734927} # lost: 0
limits['SH_tran/UC/dist/95.00'] = {'max': 7.7213933394205414, 'min': 6.9077865250381665} # lost: 18
limits['SH_tran/UC/dist/99.00'] = {'max': 7.7948307483885841, 'min': 6.4524516236510614} # lost: 3
limits['SH_tran/UC/dist/99.50'] = {'max': 7.79732740743533, 'min': 6.4523862439734927} # lost: 1
limits['SH_tran/UC/dist/99.90'] = {'max': 7.8021266423362592, 'min': 6.4523862439734927} # lost: 0
limits['SH_tran/UC/dist/99.99'] = {'max': 7.8021266423362592, 'min': 6.4523862439734927} # lost: 0
limits['SH_tran/UC/min_dist/100.00'] = {'max': 2.3487421442631131, 'min': 1.3779134863627789} # lost: 0
limits['SH_tran/UC/min_dist/95.00'] = {'max': 2.1774878588734778, 'min': 1.5768670106690921} # lost: 18
limits['SH_tran/UC/min_dist/99.00'] = {'max': 2.2248448477568861, 'min': 1.4024720589188566} # lost: 3
limits['SH_tran/UC/min_dist/99.50'] = {'max': 2.2604691413661953, 'min': 1.3779134863627789} # lost: 1
limits['SH_tran/UC/min_dist/99.90'] = {'max': 2.3487421442631131, 'min': 1.3779134863627789} # lost: 0
limits['SH_tran/UC/min_dist/99.99'] = {'max': 2.3487421442631131, 'min': 1.3779134863627789} # lost: 0
limits['SH_tran/UC/n2_z/100.00'] = {'max': -0.57937223, 'min': -0.99995977} # lost: 0
limits['SH_tran/UC/n2_z/95.00'] = {'max': -0.75438595, 'min': -0.99995977} # lost: 18
limits['SH_tran/UC/n2_z/99.00'] = {'max': -0.6957705, 'min': -0.99995977} # lost: 3
limits['SH_tran/UC/n2_z/99.50'] = {'max': -0.69365627, 'min': -0.99995977} # lost: 1
limits['SH_tran/UC/n2_z/99.90'] = {'max': -0.57937223, 'min': -0.99995977} # lost: 0
limits['SH_tran/UC/n2_z/99.99'] = {'max': -0.57937223, 'min': -0.99995977} # lost: 0
limits['SH_tran/UC/nn_ang_norm/100.00'] = {'max': 48.537996667308931, 'min': 0.7263173073828284} # lost: 0
limits['SH_tran/UC/nn_ang_norm/95.00'] = {'max': 41.489118500450701, 'min': 0.7263173073828284} # lost: 18
limits['SH_tran/UC/nn_ang_norm/99.00'] = {'max': 45.457758936551585, 'min': 0.7263173073828284} # lost: 3
limits['SH_tran/UC/nn_ang_norm/99.50'] = {'max': 46.831036771074366, 'min': 0.7263173073828284} # lost: 1
limits['SH_tran/UC/nn_ang_norm/99.90'] = {'max': 48.537996667308931, 'min': 0.7263173073828284} # lost: 0
limits['SH_tran/UC/nn_ang_norm/99.99'] = {'max': 48.537996667308931, 'min': 0.7263173073828284} # lost: 0
limits['SH_tran/UC/rot_ang/100.00'] = {'max': 120.9978939499244, 'min': 67.503945484387401} # lost: 0
limits['SH_tran/UC/rot_ang/95.00'] = {'max': 113.38182120892549, 'min': 70.937937163284985} # lost: 18
limits['SH_tran/UC/rot_ang/99.00'] = {'max': 119.97280912581418, 'min': 67.834709608276796} # lost: 3
limits['SH_tran/UC/rot_ang/99.50'] = {'max': 120.11012846715828, 'min': 67.503945484387401} # lost: 1
limits['SH_tran/UC/rot_ang/99.90'] = {'max': 120.9978939499244, 'min': 67.503945484387401} # lost: 0
limits['SH_tran/UC/rot_ang/99.99'] = {'max': 120.9978939499244, 'min': 67.503945484387401} # lost: 0
limits['SH_tran/UG/dist/100.00'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['SH_tran/UG/dist/95.00'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['SH_tran/UG/dist/99.00'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['SH_tran/UG/dist/99.50'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['SH_tran/UG/dist/99.90'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['SH_tran/UG/dist/99.99'] = {'max': 7.6548130598194133, 'min': 7.6548130598194133} # lost: 0
limits['SH_tran/UG/min_dist/100.00'] = {'max': 2.9590567610195158, 'min': 2.9590567610195158} # lost: 0
limits['SH_tran/UG/min_dist/95.00'] = {'max': 2.9590567610195158, 'min': 2.9590567610195158} # lost: 0
limits['SH_tran/UG/min_dist/99.00'] = {'max': 2.9590567610195158, 'min': 2.9590567610195158} # lost: 0
limits['SH_tran/UG/min_dist/99.50'] = {'max': 2.9590567610195158, 'min': 2.9590567610195158} # lost: 0
limits['SH_tran/UG/min_dist/99.90'] = {'max': 2.9590567610195158, 'min': 2.9590567610195158} # lost: 0
limits['SH_tran/UG/min_dist/99.99'] = {'max': 2.9590567610195158, 'min': 2.9590567610195158} # lost: 0
limits['SH_tran/UG/n2_z/100.00'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['SH_tran/UG/n2_z/95.00'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['SH_tran/UG/n2_z/99.00'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['SH_tran/UG/n2_z/99.50'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['SH_tran/UG/n2_z/99.90'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['SH_tran/UG/n2_z/99.99'] = {'max': -0.99981999, 'min': -0.99981999} # lost: 0
limits['SH_tran/UG/nn_ang_norm/100.00'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['SH_tran/UG/nn_ang_norm/95.00'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['SH_tran/UG/nn_ang_norm/99.00'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['SH_tran/UG/nn_ang_norm/99.50'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['SH_tran/UG/nn_ang_norm/99.90'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['SH_tran/UG/nn_ang_norm/99.99'] = {'max': 0.8556947506411916, 'min': 0.8556947506411916} # lost: 0
limits['SH_tran/UG/rot_ang/100.00'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['SH_tran/UG/rot_ang/95.00'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['SH_tran/UG/rot_ang/99.00'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['SH_tran/UG/rot_ang/99.50'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['SH_tran/UG/rot_ang/99.90'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['SH_tran/UG/rot_ang/99.99'] = {'max': 91.412390769645512, 'min': 91.412390769645512} # lost: 0
limits['SH_tran/UU/dist/100.00'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['SH_tran/UU/dist/95.00'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['SH_tran/UU/dist/99.00'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['SH_tran/UU/dist/99.50'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['SH_tran/UU/dist/99.90'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['SH_tran/UU/dist/99.99'] = {'max': 7.6217947393970347, 'min': 7.6217947393970347} # lost: 0
limits['SH_tran/UU/min_dist/100.00'] = {'max': 3.1795720252364381, 'min': 3.1795720252364381} # lost: 0
limits['SH_tran/UU/min_dist/95.00'] = {'max': 3.1795720252364381, 'min': 3.1795720252364381} # lost: 0
limits['SH_tran/UU/min_dist/99.00'] = {'max': 3.1795720252364381, 'min': 3.1795720252364381} # lost: 0
limits['SH_tran/UU/min_dist/99.50'] = {'max': 3.1795720252364381, 'min': 3.1795720252364381} # lost: 0
limits['SH_tran/UU/min_dist/99.90'] = {'max': 3.1795720252364381, 'min': 3.1795720252364381} # lost: 0
limits['SH_tran/UU/min_dist/99.99'] = {'max': 3.1795720252364381, 'min': 3.1795720252364381} # lost: 0
limits['SH_tran/UU/n2_z/100.00'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['SH_tran/UU/n2_z/95.00'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['SH_tran/UU/n2_z/99.00'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['SH_tran/UU/n2_z/99.50'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['SH_tran/UU/n2_z/99.90'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['SH_tran/UU/n2_z/99.99'] = {'max': -0.99672669, 'min': -0.99672669} # lost: 0
limits['SH_tran/UU/nn_ang_norm/100.00'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['SH_tran/UU/nn_ang_norm/95.00'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['SH_tran/UU/nn_ang_norm/99.00'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['SH_tran/UU/nn_ang_norm/99.50'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['SH_tran/UU/nn_ang_norm/99.90'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['SH_tran/UU/nn_ang_norm/99.99'] = {'max': 5.2069897048028793, 'min': 5.2069897048028793} # lost: 0
limits['SH_tran/UU/rot_ang/100.00'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['SH_tran/UU/rot_ang/95.00'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['SH_tran/UU/rot_ang/99.00'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['SH_tran/UU/rot_ang/99.50'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['SH_tran/UU/rot_ang/99.90'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['SH_tran/UU/rot_ang/99.99'] = {'max': 110.87020404260443, 'min': 110.87020404260443} # lost: 0
limits['SS_cis/AA/dist/100.00'] = {'max': 5.3562462633824852, 'min': 5.1504439772430075} # lost: 0
limits['SS_cis/AA/dist/95.00'] = {'max': 5.3562462633824852, 'min': 5.1504439772430075} # lost: 0
limits['SS_cis/AA/dist/99.00'] = {'max': 5.3562462633824852, 'min': 5.1504439772430075} # lost: 0
limits['SS_cis/AA/dist/99.50'] = {'max': 5.3562462633824852, 'min': 5.1504439772430075} # lost: 0
limits['SS_cis/AA/dist/99.90'] = {'max': 5.3562462633824852, 'min': 5.1504439772430075} # lost: 0
limits['SS_cis/AA/dist/99.99'] = {'max': 5.3562462633824852, 'min': 5.1504439772430075} # lost: 0
limits['SS_cis/AA/min_dist/100.00'] = {'max': 2.5330252338709891, 'min': 1.7237649825640902} # lost: 0
limits['SS_cis/AA/min_dist/95.00'] = {'max': 2.5330252338709891, 'min': 1.7237649825640902} # lost: 0
limits['SS_cis/AA/min_dist/99.00'] = {'max': 2.5330252338709891, 'min': 1.7237649825640902} # lost: 0
limits['SS_cis/AA/min_dist/99.50'] = {'max': 2.5330252338709891, 'min': 1.7237649825640902} # lost: 0
limits['SS_cis/AA/min_dist/99.90'] = {'max': 2.5330252338709891, 'min': 1.7237649825640902} # lost: 0
limits['SS_cis/AA/min_dist/99.99'] = {'max': 2.5330252338709891, 'min': 1.7237649825640902} # lost: 0
limits['SS_cis/AA/n2_z/100.00'] = {'max': -0.75238162, 'min': -0.89048362} # lost: 0
limits['SS_cis/AA/n2_z/95.00'] = {'max': -0.75238162, 'min': -0.89048362} # lost: 0
limits['SS_cis/AA/n2_z/99.00'] = {'max': -0.75238162, 'min': -0.89048362} # lost: 0
limits['SS_cis/AA/n2_z/99.50'] = {'max': -0.75238162, 'min': -0.89048362} # lost: 0
limits['SS_cis/AA/n2_z/99.90'] = {'max': -0.75238162, 'min': -0.89048362} # lost: 0
limits['SS_cis/AA/n2_z/99.99'] = {'max': -0.75238162, 'min': -0.89048362} # lost: 0
limits['SS_cis/AA/nn_ang_norm/100.00'] = {'max': 40.578203491602778, 'min': 26.95761783368178} # lost: 0
limits['SS_cis/AA/nn_ang_norm/95.00'] = {'max': 40.578203491602778, 'min': 26.95761783368178} # lost: 0
limits['SS_cis/AA/nn_ang_norm/99.00'] = {'max': 40.578203491602778, 'min': 26.95761783368178} # lost: 0
limits['SS_cis/AA/nn_ang_norm/99.50'] = {'max': 40.578203491602778, 'min': 26.95761783368178} # lost: 0
limits['SS_cis/AA/nn_ang_norm/99.90'] = {'max': 40.578203491602778, 'min': 26.95761783368178} # lost: 0
limits['SS_cis/AA/nn_ang_norm/99.99'] = {'max': 40.578203491602778, 'min': 26.95761783368178} # lost: 0
limits['SS_cis/AA/rot_ang/100.00'] = {'max': -66.016617518005248, 'min': -80.200880783052824} # lost: 0
limits['SS_cis/AA/rot_ang/95.00'] = {'max': -66.016617518005248, 'min': -80.200880783052824} # lost: 0
limits['SS_cis/AA/rot_ang/99.00'] = {'max': -66.016617518005248, 'min': -80.200880783052824} # lost: 0
limits['SS_cis/AA/rot_ang/99.50'] = {'max': -66.016617518005248, 'min': -80.200880783052824} # lost: 0
limits['SS_cis/AA/rot_ang/99.90'] = {'max': -66.016617518005248, 'min': -80.200880783052824} # lost: 0
limits['SS_cis/AA/rot_ang/99.99'] = {'max': -66.016617518005248, 'min': -80.200880783052824} # lost: 0
limits['SS_cis/AC/dist/100.00'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/AC/dist/95.00'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/AC/dist/99.00'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/AC/dist/99.50'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/AC/dist/99.90'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/AC/dist/99.99'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/AC/min_dist/100.00'] = {'max': 1.9681187489546199, 'min': 1.109868499567525} # lost: 0
limits['SS_cis/AC/min_dist/95.00'] = {'max': 1.9681187489546199, 'min': 1.109868499567525} # lost: 0
limits['SS_cis/AC/min_dist/99.00'] = {'max': 1.9681187489546199, 'min': 1.109868499567525} # lost: 0
limits['SS_cis/AC/min_dist/99.50'] = {'max': 1.9681187489546199, 'min': 1.109868499567525} # lost: 0
limits['SS_cis/AC/min_dist/99.90'] = {'max': 1.9681187489546199, 'min': 1.109868499567525} # lost: 0
limits['SS_cis/AC/min_dist/99.99'] = {'max': 1.9681187489546199, 'min': 1.109868499567525} # lost: 0
limits['SS_cis/AC/n2_z/100.00'] = {'max': -0.66079128, 'min': -0.96455485} # lost: 0
limits['SS_cis/AC/n2_z/95.00'] = {'max': -0.66079128, 'min': -0.96455485} # lost: 0
limits['SS_cis/AC/n2_z/99.00'] = {'max': -0.66079128, 'min': -0.96455485} # lost: 0
limits['SS_cis/AC/n2_z/99.50'] = {'max': -0.66079128, 'min': -0.96455485} # lost: 0
limits['SS_cis/AC/n2_z/99.90'] = {'max': -0.66079128, 'min': -0.96455485} # lost: 0
limits['SS_cis/AC/n2_z/99.99'] = {'max': -0.66079128, 'min': -0.96455485} # lost: 0
limits['SS_cis/AC/nn_ang_norm/100.00'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/AC/nn_ang_norm/95.00'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/AC/nn_ang_norm/99.00'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/AC/nn_ang_norm/99.50'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/AC/nn_ang_norm/99.90'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/AC/nn_ang_norm/99.99'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/AC/rot_ang/100.00'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/AC/rot_ang/95.00'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/AC/rot_ang/99.00'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/AC/rot_ang/99.50'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/AC/rot_ang/99.90'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/AC/rot_ang/99.99'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/AG/dist/100.00'] = {'max': 7.435971823076108, 'min': 4.8594600216024686} # lost: 0
limits['SS_cis/AG/dist/95.00'] = {'max': 7.2049481745387531, 'min': 5.3797315232114249} # lost: 172
limits['SS_cis/AG/dist/99.00'] = {'max': 7.2803027394673014, 'min': 5.1987839469987405} # lost: 34
limits['SS_cis/AG/dist/99.50'] = {'max': 7.3114993796909822, 'min': 5.1226367768867576} # lost: 17
limits['SS_cis/AG/dist/99.90'] = {'max': 7.3522622447111541, 'min': 5.073079802685946} # lost: 3
limits['SS_cis/AG/dist/99.99'] = {'max': 7.435971823076108, 'min': 4.8594600216024686} # lost: 0
limits['SS_cis/AG/min_dist/100.00'] = {'max': 2.9579877226346931, 'min': 0.91798681371192792} # lost: 0
limits['SS_cis/AG/min_dist/95.00'] = {'max': 2.5934030339317742, 'min': 1.7283277129409118} # lost: 172
limits['SS_cis/AG/min_dist/99.00'] = {'max': 2.7233397295965811, 'min': 1.5264824606743355} # lost: 34
limits['SS_cis/AG/min_dist/99.50'] = {'max': 2.7631253785024081, 'min': 1.4053699659160235} # lost: 17
limits['SS_cis/AG/min_dist/99.90'] = {'max': 2.8696950948559645, 'min': 1.2599798416215406} # lost: 3
limits['SS_cis/AG/min_dist/99.99'] = {'max': 2.9579877226346931, 'min': 0.91798681371192792} # lost: 0
limits['SS_cis/AG/n2_z/100.00'] = {'max': -0.44773543, 'min': -0.99998242} # lost: 0
limits['SS_cis/AG/n2_z/95.00'] = {'max': -0.61130917, 'min': -0.99998242} # lost: 172
limits['SS_cis/AG/n2_z/99.00'] = {'max': -0.52747488, 'min': -0.99998242} # lost: 34
limits['SS_cis/AG/n2_z/99.50'] = {'max': -0.511186, 'min': -0.99998242} # lost: 17
limits['SS_cis/AG/n2_z/99.90'] = {'max': -0.50117803, 'min': -0.99998242} # lost: 3
limits['SS_cis/AG/n2_z/99.99'] = {'max': -0.44773543, 'min': -0.99998242} # lost: 0
limits['SS_cis/AG/nn_ang_norm/100.00'] = {'max': 63.26492270661025, 'min': 0.34661343104346543} # lost: 0
limits['SS_cis/AG/nn_ang_norm/95.00'] = {'max': 52.463552270125362, 'min': 0.34661343104346543} # lost: 172
limits['SS_cis/AG/nn_ang_norm/99.00'] = {'max': 58.389793224243618, 'min': 0.34661343104346543} # lost: 34
limits['SS_cis/AG/nn_ang_norm/99.50'] = {'max': 59.265560079622645, 'min': 0.34661343104346543} # lost: 17
limits['SS_cis/AG/nn_ang_norm/99.90'] = {'max': 61.230878711402113, 'min': 0.34661343104346543} # lost: 3
limits['SS_cis/AG/nn_ang_norm/99.99'] = {'max': 63.26492270661025, 'min': 0.34661343104346543} # lost: 0
limits['SS_cis/AG/rot_ang/100.00'] = {'max2': -51.74998444547856, 'min1': 225.53361439352602, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/AG/rot_ang/95.00'] = {'max2': -59.906296260331658, 'min1': 258.92481364489106, 'min2': -90.0, 'max1': 270.0} # lost: 172
limits['SS_cis/AG/rot_ang/99.00'] = {'max2': -56.052486378329718, 'min1': 254.99146190736587, 'min2': -90.0, 'max1': 270.0} # lost: 34
limits['SS_cis/AG/rot_ang/99.50'] = {'max2': -55.167769420029572, 'min1': 252.44868095436806, 'min2': -90.0, 'max1': 270.0} # lost: 17
limits['SS_cis/AG/rot_ang/99.90'] = {'max2': -53.00557625168841, 'min1': 232.57210234685931, 'min2': -90.0, 'max1': 270.0} # lost: 3
limits['SS_cis/AG/rot_ang/99.99'] = {'max2': -51.74998444547856, 'min1': 225.53361439352602, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/AU/dist/100.00'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/AU/dist/95.00'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/AU/dist/99.00'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/AU/dist/99.50'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/AU/dist/99.90'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/AU/dist/99.99'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/AU/min_dist/100.00'] = {'max': 2.2294147861790057, 'min': 1.4249488350950037} # lost: 0
limits['SS_cis/AU/min_dist/95.00'] = {'max': 2.2294147861790057, 'min': 1.4249488350950037} # lost: 0
limits['SS_cis/AU/min_dist/99.00'] = {'max': 2.2294147861790057, 'min': 1.4249488350950037} # lost: 0
limits['SS_cis/AU/min_dist/99.50'] = {'max': 2.2294147861790057, 'min': 1.4249488350950037} # lost: 0
limits['SS_cis/AU/min_dist/99.90'] = {'max': 2.2294147861790057, 'min': 1.4249488350950037} # lost: 0
limits['SS_cis/AU/min_dist/99.99'] = {'max': 2.2294147861790057, 'min': 1.4249488350950037} # lost: 0
limits['SS_cis/AU/n2_z/100.00'] = {'max': -0.66524643, 'min': -0.97320795} # lost: 0
limits['SS_cis/AU/n2_z/95.00'] = {'max': -0.66524643, 'min': -0.97320795} # lost: 0
limits['SS_cis/AU/n2_z/99.00'] = {'max': -0.66524643, 'min': -0.97320795} # lost: 0
limits['SS_cis/AU/n2_z/99.50'] = {'max': -0.66524643, 'min': -0.97320795} # lost: 0
limits['SS_cis/AU/n2_z/99.90'] = {'max': -0.66524643, 'min': -0.97320795} # lost: 0
limits['SS_cis/AU/n2_z/99.99'] = {'max': -0.66524643, 'min': -0.97320795} # lost: 0
limits['SS_cis/AU/nn_ang_norm/100.00'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/AU/nn_ang_norm/95.00'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/AU/nn_ang_norm/99.00'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/AU/nn_ang_norm/99.50'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/AU/nn_ang_norm/99.90'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/AU/nn_ang_norm/99.99'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/AU/rot_ang/100.00'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/AU/rot_ang/95.00'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/AU/rot_ang/99.00'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/AU/rot_ang/99.50'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/AU/rot_ang/99.90'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/AU/rot_ang/99.99'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/CA/dist/100.00'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/CA/dist/95.00'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/CA/dist/99.00'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/CA/dist/99.50'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/CA/dist/99.90'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/CA/dist/99.99'] = {'max': 6.4375741322063158, 'min': 5.845392698199027} # lost: 0
limits['SS_cis/CA/min_dist/100.00'] = {'max': 1.9681310585593819, 'min': 1.10985824631886} # lost: 0
limits['SS_cis/CA/min_dist/95.00'] = {'max': 1.9681310585593819, 'min': 1.10985824631886} # lost: 0
limits['SS_cis/CA/min_dist/99.00'] = {'max': 1.9681310585593819, 'min': 1.10985824631886} # lost: 0
limits['SS_cis/CA/min_dist/99.50'] = {'max': 1.9681310585593819, 'min': 1.10985824631886} # lost: 0
limits['SS_cis/CA/min_dist/99.90'] = {'max': 1.9681310585593819, 'min': 1.10985824631886} # lost: 0
limits['SS_cis/CA/min_dist/99.99'] = {'max': 1.9681310585593819, 'min': 1.10985824631886} # lost: 0
limits['SS_cis/CA/n2_z/100.00'] = {'max': -0.66079116, 'min': -0.96455473} # lost: 0
limits['SS_cis/CA/n2_z/95.00'] = {'max': -0.66079116, 'min': -0.96455473} # lost: 0
limits['SS_cis/CA/n2_z/99.00'] = {'max': -0.66079116, 'min': -0.96455473} # lost: 0
limits['SS_cis/CA/n2_z/99.50'] = {'max': -0.66079116, 'min': -0.96455473} # lost: 0
limits['SS_cis/CA/n2_z/99.90'] = {'max': -0.66079116, 'min': -0.96455473} # lost: 0
limits['SS_cis/CA/n2_z/99.99'] = {'max': -0.66079116, 'min': -0.96455473} # lost: 0
limits['SS_cis/CA/nn_ang_norm/100.00'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/CA/nn_ang_norm/95.00'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/CA/nn_ang_norm/99.00'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/CA/nn_ang_norm/99.50'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/CA/nn_ang_norm/99.90'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/CA/nn_ang_norm/99.99'] = {'max': 48.874192238635288, 'min': 15.396744021869807} # lost: 0
limits['SS_cis/CA/rot_ang/100.00'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/CA/rot_ang/95.00'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/CA/rot_ang/99.00'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/CA/rot_ang/99.50'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/CA/rot_ang/99.90'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/CA/rot_ang/99.99'] = {'max': -56.801297881784876, 'min': -85.010399880101417} # lost: 0
limits['SS_cis/CG/dist/100.00'] = {'max': 8.0681377721097611, 'min': 5.9709617665517172} # lost: 0
limits['SS_cis/CG/dist/95.00'] = {'max': 7.855476864118458, 'min': 6.6704222361351881} # lost: 33
limits['SS_cis/CG/dist/99.00'] = {'max': 8.057991349802311, 'min': 6.0244075737258722} # lost: 6
limits['SS_cis/CG/dist/99.50'] = {'max': 8.0629564393290956, 'min': 5.9874036494706493} # lost: 3
limits['SS_cis/CG/dist/99.90'] = {'max': 8.0681377721097611, 'min': 5.9709617665517172} # lost: 0
limits['SS_cis/CG/dist/99.99'] = {'max': 8.0681377721097611, 'min': 5.9709617665517172} # lost: 0
limits['SS_cis/CG/min_dist/100.00'] = {'max': 2.7775839429657903, 'min': 1.3255641214758882} # lost: 0
limits['SS_cis/CG/min_dist/95.00'] = {'max': 2.5541954050360016, 'min': 1.5871739796891087} # lost: 33
limits['SS_cis/CG/min_dist/99.00'] = {'max': 2.6982483071754237, 'min': 1.47342640150643} # lost: 6
limits['SS_cis/CG/min_dist/99.50'] = {'max': 2.7132787905138578, 'min': 1.3384281418879567} # lost: 3
limits['SS_cis/CG/min_dist/99.90'] = {'max': 2.7775839429657903, 'min': 1.3255641214758882} # lost: 0
limits['SS_cis/CG/min_dist/99.99'] = {'max': 2.7775839429657903, 'min': 1.3255641214758882} # lost: 0
limits['SS_cis/CG/n2_z/100.00'] = {'max': -0.54453194, 'min': -0.99885446} # lost: 0
limits['SS_cis/CG/n2_z/95.00'] = {'max': -0.68907315, 'min': -0.99885446} # lost: 33
limits['SS_cis/CG/n2_z/99.00'] = {'max': -0.61003661, 'min': -0.99885446} # lost: 6
limits['SS_cis/CG/n2_z/99.50'] = {'max': -0.59433484, 'min': -0.99885446} # lost: 3
limits['SS_cis/CG/n2_z/99.90'] = {'max': -0.54453194, 'min': -0.99885446} # lost: 0
limits['SS_cis/CG/n2_z/99.99'] = {'max': -0.54453194, 'min': -0.99885446} # lost: 0
limits['SS_cis/CG/nn_ang_norm/100.00'] = {'max': 56.955248592865829, 'min': 3.4469592387173122} # lost: 0
limits['SS_cis/CG/nn_ang_norm/95.00'] = {'max': 46.76004378484123, 'min': 3.4469592387173122} # lost: 33
limits['SS_cis/CG/nn_ang_norm/99.00'] = {'max': 52.905479169803527, 'min': 3.4469592387173122} # lost: 6
limits['SS_cis/CG/nn_ang_norm/99.50'] = {'max': 55.165902954862574, 'min': 3.4469592387173122} # lost: 3
limits['SS_cis/CG/nn_ang_norm/99.90'] = {'max': 56.955248592865829, 'min': 3.4469592387173122} # lost: 0
limits['SS_cis/CG/nn_ang_norm/99.99'] = {'max': 56.955248592865829, 'min': 3.4469592387173122} # lost: 0
limits['SS_cis/CG/rot_ang/100.00'] = {'max2': -66.061552203483359, 'min1': 230.67709223481461, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/CG/rot_ang/95.00'] = {'max2': -79.646621842613285, 'min1': 238.58609001031544, 'min2': -90.0, 'max1': 270.0} # lost: 33
limits['SS_cis/CG/rot_ang/99.00'] = {'max2': -69.784804993678904, 'min1': 233.96974032657846, 'min2': -90.0, 'max1': 270.0} # lost: 6
limits['SS_cis/CG/rot_ang/99.50'] = {'max2': -69.65013029334267, 'min1': 231.7630315420204, 'min2': -90.0, 'max1': 270.0} # lost: 3
limits['SS_cis/CG/rot_ang/99.90'] = {'max2': -66.061552203483359, 'min1': 230.67709223481461, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/CG/rot_ang/99.99'] = {'max2': -66.061552203483359, 'min1': 230.67709223481461, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GA/dist/100.00'] = {'max': 7.435971823076108, 'min': 4.8594600216024686} # lost: 0
limits['SS_cis/GA/dist/95.00'] = {'max': 7.2049481745387531, 'min': 5.3797315232114249} # lost: 172
limits['SS_cis/GA/dist/99.00'] = {'max': 7.2803027394673014, 'min': 5.1987839469987405} # lost: 34
limits['SS_cis/GA/dist/99.50'] = {'max': 7.3114993796909822, 'min': 5.1226367768867576} # lost: 17
limits['SS_cis/GA/dist/99.90'] = {'max': 7.3522622447111541, 'min': 5.073079802685946} # lost: 3
limits['SS_cis/GA/dist/99.99'] = {'max': 7.435971823076108, 'min': 4.8594600216024686} # lost: 0
limits['SS_cis/GA/min_dist/100.00'] = {'max': 2.9579861253341266, 'min': 0.91798790362974958} # lost: 0
limits['SS_cis/GA/min_dist/95.00'] = {'max': 2.5934106678503279, 'min': 1.7283160728078082} # lost: 172
limits['SS_cis/GA/min_dist/99.00'] = {'max': 2.7233406556082529, 'min': 1.5264952721045537} # lost: 34
limits['SS_cis/GA/min_dist/99.50'] = {'max': 2.763122040758538, 'min': 1.4053674186618557} # lost: 17
limits['SS_cis/GA/min_dist/99.90'] = {'max': 2.8696941340252589, 'min': 1.2599644655871438} # lost: 3
limits['SS_cis/GA/min_dist/99.99'] = {'max': 2.9579861253341266, 'min': 0.91798790362974958} # lost: 0
limits['SS_cis/GA/n2_z/100.00'] = {'max': -0.44773561, 'min': -0.99998242} # lost: 0
limits['SS_cis/GA/n2_z/95.00'] = {'max': -0.61130929, 'min': -0.99998242} # lost: 172
limits['SS_cis/GA/n2_z/99.00'] = {'max': -0.52747524, 'min': -0.99998242} # lost: 34
limits['SS_cis/GA/n2_z/99.50'] = {'max': -0.51118565, 'min': -0.99998242} # lost: 17
limits['SS_cis/GA/n2_z/99.90'] = {'max': -0.50117773, 'min': -0.99998242} # lost: 3
limits['SS_cis/GA/n2_z/99.99'] = {'max': -0.44773561, 'min': -0.99998242} # lost: 0
limits['SS_cis/GA/nn_ang_norm/100.00'] = {'max': 63.26492270661025, 'min': 0.34661343104346543} # lost: 0
limits['SS_cis/GA/nn_ang_norm/95.00'] = {'max': 52.463552270125362, 'min': 0.34661343104346543} # lost: 172
limits['SS_cis/GA/nn_ang_norm/99.00'] = {'max': 58.389793224243618, 'min': 0.34661343104346543} # lost: 34
limits['SS_cis/GA/nn_ang_norm/99.50'] = {'max': 59.265560079622645, 'min': 0.34661343104346543} # lost: 17
limits['SS_cis/GA/nn_ang_norm/99.90'] = {'max': 61.230878711402113, 'min': 0.34661343104346543} # lost: 3
limits['SS_cis/GA/nn_ang_norm/99.99'] = {'max': 63.26492270661025, 'min': 0.34661343104346543} # lost: 0
limits['SS_cis/GA/rot_ang/100.00'] = {'max2': -51.74998444547856, 'min1': 225.53361439352602, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GA/rot_ang/95.00'] = {'max2': -59.906296260331658, 'min1': 258.92481364489106, 'min2': -90.0, 'max1': 270.0} # lost: 172
limits['SS_cis/GA/rot_ang/99.00'] = {'max2': -56.052486378329718, 'min1': 254.99146190736587, 'min2': -90.0, 'max1': 270.0} # lost: 34
limits['SS_cis/GA/rot_ang/99.50'] = {'max2': -55.167769420029572, 'min1': 252.44868095436806, 'min2': -90.0, 'max1': 270.0} # lost: 17
limits['SS_cis/GA/rot_ang/99.90'] = {'max2': -53.00557625168841, 'min1': 232.57210234685931, 'min2': -90.0, 'max1': 270.0} # lost: 3
limits['SS_cis/GA/rot_ang/99.99'] = {'max2': -51.74998444547856, 'min1': 225.53361439352602, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GC/dist/100.00'] = {'max': 8.0681377721097611, 'min': 5.9709617665517172} # lost: 0
limits['SS_cis/GC/dist/95.00'] = {'max': 7.855476864118458, 'min': 6.6704222361351881} # lost: 33
limits['SS_cis/GC/dist/99.00'] = {'max': 8.057991349802311, 'min': 6.0244075737258722} # lost: 6
limits['SS_cis/GC/dist/99.50'] = {'max': 8.0629564393290956, 'min': 5.9874036494706493} # lost: 3
limits['SS_cis/GC/dist/99.90'] = {'max': 8.0681377721097611, 'min': 5.9709617665517172} # lost: 0
limits['SS_cis/GC/dist/99.99'] = {'max': 8.0681377721097611, 'min': 5.9709617665517172} # lost: 0
limits['SS_cis/GC/min_dist/100.00'] = {'max': 2.7775796760473117, 'min': 1.3255738959068355} # lost: 0
limits['SS_cis/GC/min_dist/95.00'] = {'max': 2.5541985470658615, 'min': 1.5871616248497229} # lost: 33
limits['SS_cis/GC/min_dist/99.00'] = {'max': 2.6982437390871854, 'min': 1.4734330664275479} # lost: 6
limits['SS_cis/GC/min_dist/99.50'] = {'max': 2.7132896077580915, 'min': 1.3384261410146774} # lost: 3
limits['SS_cis/GC/min_dist/99.90'] = {'max': 2.7775796760473117, 'min': 1.3255738959068355} # lost: 0
limits['SS_cis/GC/min_dist/99.99'] = {'max': 2.7775796760473117, 'min': 1.3255738959068355} # lost: 0
limits['SS_cis/GC/n2_z/100.00'] = {'max': -0.54453194, 'min': -0.99885446} # lost: 0
limits['SS_cis/GC/n2_z/95.00'] = {'max': -0.68907332, 'min': -0.99885446} # lost: 33
limits['SS_cis/GC/n2_z/99.00'] = {'max': -0.61003685, 'min': -0.99885446} # lost: 6
limits['SS_cis/GC/n2_z/99.50'] = {'max': -0.5943349, 'min': -0.99885446} # lost: 3
limits['SS_cis/GC/n2_z/99.90'] = {'max': -0.54453194, 'min': -0.99885446} # lost: 0
limits['SS_cis/GC/n2_z/99.99'] = {'max': -0.54453194, 'min': -0.99885446} # lost: 0
limits['SS_cis/GC/nn_ang_norm/100.00'] = {'max': 56.955248592865829, 'min': 3.4469592387173122} # lost: 0
limits['SS_cis/GC/nn_ang_norm/95.00'] = {'max': 46.76004378484123, 'min': 3.4469592387173122} # lost: 33
limits['SS_cis/GC/nn_ang_norm/99.00'] = {'max': 52.905479169803527, 'min': 3.4469592387173122} # lost: 6
limits['SS_cis/GC/nn_ang_norm/99.50'] = {'max': 55.165902954862574, 'min': 3.4469592387173122} # lost: 3
limits['SS_cis/GC/nn_ang_norm/99.90'] = {'max': 56.955248592865829, 'min': 3.4469592387173122} # lost: 0
limits['SS_cis/GC/nn_ang_norm/99.99'] = {'max': 56.955248592865829, 'min': 3.4469592387173122} # lost: 0
limits['SS_cis/GC/rot_ang/100.00'] = {'max2': -66.061552203483359, 'min1': 230.67709223481461, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GC/rot_ang/95.00'] = {'max2': -79.646621842613285, 'min1': 238.58609001031544, 'min2': -90.0, 'max1': 270.0} # lost: 33
limits['SS_cis/GC/rot_ang/99.00'] = {'max2': -69.784804993678904, 'min1': 233.96974032657846, 'min2': -90.0, 'max1': 270.0} # lost: 6
limits['SS_cis/GC/rot_ang/99.50'] = {'max2': -69.65013029334267, 'min1': 231.7630315420204, 'min2': -90.0, 'max1': 270.0} # lost: 3
limits['SS_cis/GC/rot_ang/99.90'] = {'max2': -66.061552203483359, 'min1': 230.67709223481461, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GC/rot_ang/99.99'] = {'max2': -66.061552203483359, 'min1': 230.67709223481461, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GG/dist/100.00'] = {'max': 7.2782545679035522, 'min': 6.1376722307149487} # lost: 0
limits['SS_cis/GG/dist/95.00'] = {'max': 7.1120750730772828, 'min': 6.3893151228185534} # lost: 29
limits['SS_cis/GG/dist/99.00'] = {'max': 7.2643793279124429, 'min': 6.2204796226644428} # lost: 5
limits['SS_cis/GG/dist/99.50'] = {'max': 7.2782545679035522, 'min': 6.1376722307149487} # lost: 2
limits['SS_cis/GG/dist/99.90'] = {'max': 7.2782545679035522, 'min': 6.1376722307149487} # lost: 0
limits['SS_cis/GG/dist/99.99'] = {'max': 7.2782545679035522, 'min': 6.1376722307149487} # lost: 0
limits['SS_cis/GG/min_dist/100.00'] = {'max': 2.5746447523694056, 'min': 1.2575903749502277} # lost: 0
limits['SS_cis/GG/min_dist/95.00'] = {'max': 2.4297829512968518, 'min': 1.6548879095550291} # lost: 29
limits['SS_cis/GG/min_dist/99.00'] = {'max': 2.5716545590422788, 'min': 1.4017582869736307} # lost: 5
limits['SS_cis/GG/min_dist/99.50'] = {'max': 2.5746356495598421, 'min': 1.2575917717762588} # lost: 2
limits['SS_cis/GG/min_dist/99.90'] = {'max': 2.5746447523694056, 'min': 1.2575903749502277} # lost: 0
limits['SS_cis/GG/min_dist/99.99'] = {'max': 2.5746447523694056, 'min': 1.2575903749502277} # lost: 0
limits['SS_cis/GG/n2_z/100.00'] = {'max': -0.55973965, 'min': -0.99567544} # lost: 0
limits['SS_cis/GG/n2_z/95.00'] = {'max': -0.78681529, 'min': -0.99567544} # lost: 29
limits['SS_cis/GG/n2_z/99.00'] = {'max': -0.68661249, 'min': -0.99567544} # lost: 5
limits['SS_cis/GG/n2_z/99.50'] = {'max': -0.66833609, 'min': -0.99567544} # lost: 2
limits['SS_cis/GG/n2_z/99.90'] = {'max': -0.55973965, 'min': -0.99567544} # lost: 0
limits['SS_cis/GG/n2_z/99.99'] = {'max': -0.55973965, 'min': -0.99567544} # lost: 0
limits['SS_cis/GG/nn_ang_norm/100.00'] = {'max': 55.875122477520023, 'min': 5.9395001725300745} # lost: 0
limits['SS_cis/GG/nn_ang_norm/95.00'] = {'max': 37.782811969991656, 'min': 5.9395001725300745} # lost: 29
limits['SS_cis/GG/nn_ang_norm/99.00'] = {'max': 47.069150825919337, 'min': 5.9395001725300745} # lost: 5
limits['SS_cis/GG/nn_ang_norm/99.50'] = {'max': 48.528693949659356, 'min': 5.9395001725300745} # lost: 2
limits['SS_cis/GG/nn_ang_norm/99.90'] = {'max': 55.875122477520023, 'min': 5.9395001725300745} # lost: 0
limits['SS_cis/GG/nn_ang_norm/99.99'] = {'max': 55.875122477520023, 'min': 5.9395001725300745} # lost: 0
limits['SS_cis/GG/rot_ang/100.00'] = {'max2': -83.287107920563869, 'min1': 234.16284875934426, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GG/rot_ang/95.00'] = {'max': 264.91319464465965, 'min': 238.19019007270651} # lost: 29
limits['SS_cis/GG/rot_ang/99.00'] = {'max2': -88.497451976655043, 'min1': 234.17009245540515, 'min2': -90.0, 'max1': 270.0} # lost: 5
limits['SS_cis/GG/rot_ang/99.50'] = {'max2': -83.287107920563869, 'min1': 234.16284875934426, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['SS_cis/GG/rot_ang/99.90'] = {'max2': -83.287107920563869, 'min1': 234.16284875934426, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GG/rot_ang/99.99'] = {'max2': -83.287107920563869, 'min1': 234.16284875934426, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GU/dist/100.00'] = {'max': 8.2159448509848936, 'min': 6.7508571882220174} # lost: 0
limits['SS_cis/GU/dist/95.00'] = {'max': 7.9042214358581475, 'min': 7.016519323648569} # lost: 43
limits['SS_cis/GU/dist/99.00'] = {'max': 8.0323224239040094, 'min': 6.8957156786606451} # lost: 8
limits['SS_cis/GU/dist/99.50'] = {'max': 8.1245667223672626, 'min': 6.8730177548795872} # lost: 4
limits['SS_cis/GU/dist/99.90'] = {'max': 8.2159448509848936, 'min': 6.7508571882220174} # lost: 0
limits['SS_cis/GU/dist/99.99'] = {'max': 8.2159448509848936, 'min': 6.7508571882220174} # lost: 0
limits['SS_cis/GU/min_dist/100.00'] = {'max': 2.7148574352620098, 'min': 1.3182585130158395} # lost: 0
limits['SS_cis/GU/min_dist/95.00'] = {'max': 2.5576913927893972, 'min': 1.6158290598124971} # lost: 43
limits['SS_cis/GU/min_dist/99.00'] = {'max': 2.639138083384426, 'min': 1.4649012227869211} # lost: 8
limits['SS_cis/GU/min_dist/99.50'] = {'max': 2.6456251599218588, 'min': 1.3999201586780612} # lost: 4
limits['SS_cis/GU/min_dist/99.90'] = {'max': 2.7148574352620098, 'min': 1.3182585130158395} # lost: 0
limits['SS_cis/GU/min_dist/99.99'] = {'max': 2.7148574352620098, 'min': 1.3182585130158395} # lost: 0
limits['SS_cis/GU/n2_z/100.00'] = {'max': -0.59160477, 'min': -0.99903882} # lost: 0
limits['SS_cis/GU/n2_z/95.00'] = {'max': -0.75517249, 'min': -0.99903882} # lost: 43
limits['SS_cis/GU/n2_z/99.00'] = {'max': -0.70178884, 'min': -0.99903882} # lost: 8
limits['SS_cis/GU/n2_z/99.50'] = {'max': -0.69729066, 'min': -0.99903882} # lost: 4
limits['SS_cis/GU/n2_z/99.90'] = {'max': -0.59160477, 'min': -0.99903882} # lost: 0
limits['SS_cis/GU/n2_z/99.99'] = {'max': -0.59160477, 'min': -0.99903882} # lost: 0
limits['SS_cis/GU/nn_ang_norm/100.00'] = {'max': 58.032164519301745, 'min': 2.0858118201605009} # lost: 0
limits['SS_cis/GU/nn_ang_norm/95.00'] = {'max': 40.801318451030426, 'min': 2.0858118201605009} # lost: 43
limits['SS_cis/GU/nn_ang_norm/99.00'] = {'max': 45.48479282528649, 'min': 2.0858118201605009} # lost: 8
limits['SS_cis/GU/nn_ang_norm/99.50'] = {'max': 46.880719567097032, 'min': 2.0858118201605009} # lost: 4
limits['SS_cis/GU/nn_ang_norm/99.90'] = {'max': 58.032164519301745, 'min': 2.0858118201605009} # lost: 0
limits['SS_cis/GU/nn_ang_norm/99.99'] = {'max': 58.032164519301745, 'min': 2.0858118201605009} # lost: 0
limits['SS_cis/GU/rot_ang/100.00'] = {'max2': -50.998402458989915, 'min1': 245.26329559833903, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GU/rot_ang/95.00'] = {'max2': -83.708079005306445, 'min1': 259.34402885166713, 'min2': -90.0, 'max1': 270.0} # lost: 43
limits['SS_cis/GU/rot_ang/99.00'] = {'max2': -76.391166719275532, 'min1': 252.53772224737585, 'min2': -90.0, 'max1': 270.0} # lost: 8
limits['SS_cis/GU/rot_ang/99.50'] = {'max2': -71.842245450427185, 'min1': 247.16648757075274, 'min2': -90.0, 'max1': 270.0} # lost: 4
limits['SS_cis/GU/rot_ang/99.90'] = {'max2': -50.998402458989915, 'min1': 245.26329559833903, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/GU/rot_ang/99.99'] = {'max2': -50.998402458989915, 'min1': 245.26329559833903, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/UA/dist/100.00'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/UA/dist/95.00'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/UA/dist/99.00'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/UA/dist/99.50'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/UA/dist/99.90'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/UA/dist/99.99'] = {'max': 6.5607785864544823, 'min': 5.9188346865911399} # lost: 0
limits['SS_cis/UA/min_dist/100.00'] = {'max': 2.2294154193689479, 'min': 1.4249507182706649} # lost: 0
limits['SS_cis/UA/min_dist/95.00'] = {'max': 2.2294154193689479, 'min': 1.4249507182706649} # lost: 0
limits['SS_cis/UA/min_dist/99.00'] = {'max': 2.2294154193689479, 'min': 1.4249507182706649} # lost: 0
limits['SS_cis/UA/min_dist/99.50'] = {'max': 2.2294154193689479, 'min': 1.4249507182706649} # lost: 0
limits['SS_cis/UA/min_dist/99.90'] = {'max': 2.2294154193689479, 'min': 1.4249507182706649} # lost: 0
limits['SS_cis/UA/min_dist/99.99'] = {'max': 2.2294154193689479, 'min': 1.4249507182706649} # lost: 0
limits['SS_cis/UA/n2_z/100.00'] = {'max': -0.66524631, 'min': -0.97320795} # lost: 0
limits['SS_cis/UA/n2_z/95.00'] = {'max': -0.66524631, 'min': -0.97320795} # lost: 0
limits['SS_cis/UA/n2_z/99.00'] = {'max': -0.66524631, 'min': -0.97320795} # lost: 0
limits['SS_cis/UA/n2_z/99.50'] = {'max': -0.66524631, 'min': -0.97320795} # lost: 0
limits['SS_cis/UA/n2_z/99.90'] = {'max': -0.66524631, 'min': -0.97320795} # lost: 0
limits['SS_cis/UA/n2_z/99.99'] = {'max': -0.66524631, 'min': -0.97320795} # lost: 0
limits['SS_cis/UA/nn_ang_norm/100.00'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/UA/nn_ang_norm/95.00'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/UA/nn_ang_norm/99.00'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/UA/nn_ang_norm/99.50'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/UA/nn_ang_norm/99.90'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/UA/nn_ang_norm/99.99'] = {'max': 48.398387600673857, 'min': 14.042659018914776} # lost: 0
limits['SS_cis/UA/rot_ang/100.00'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/UA/rot_ang/95.00'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/UA/rot_ang/99.00'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/UA/rot_ang/99.50'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/UA/rot_ang/99.90'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/UA/rot_ang/99.99'] = {'max': -50.919653775968719, 'min': -83.158866096677741} # lost: 0
limits['SS_cis/UG/dist/100.00'] = {'max': 8.2159448509848936, 'min': 6.7508571882220174} # lost: 0
limits['SS_cis/UG/dist/95.00'] = {'max': 7.9042214358581475, 'min': 7.016519323648569} # lost: 43
limits['SS_cis/UG/dist/99.00'] = {'max': 8.0323224239040094, 'min': 6.8957156786606451} # lost: 8
limits['SS_cis/UG/dist/99.50'] = {'max': 8.1245667223672626, 'min': 6.8730177548795872} # lost: 4
limits['SS_cis/UG/dist/99.90'] = {'max': 8.2159448509848936, 'min': 6.7508571882220174} # lost: 0
limits['SS_cis/UG/dist/99.99'] = {'max': 8.2159448509848936, 'min': 6.7508571882220174} # lost: 0
limits['SS_cis/UG/min_dist/100.00'] = {'max': 2.7148402742417526, 'min': 1.3182224439949088} # lost: 0
limits['SS_cis/UG/min_dist/95.00'] = {'max': 2.5576999467495356, 'min': 1.615826401318319} # lost: 43
limits['SS_cis/UG/min_dist/99.00'] = {'max': 2.6391364456563453, 'min': 1.4648756945524204} # lost: 8
limits['SS_cis/UG/min_dist/99.50'] = {'max': 2.6456230070246409, 'min': 1.3999135746502418} # lost: 4
limits['SS_cis/UG/min_dist/99.90'] = {'max': 2.7148402742417526, 'min': 1.3182224439949088} # lost: 0
limits['SS_cis/UG/min_dist/99.99'] = {'max': 2.7148402742417526, 'min': 1.3182224439949088} # lost: 0
limits['SS_cis/UG/n2_z/100.00'] = {'max': -0.59160465, 'min': -0.99903888} # lost: 0
limits['SS_cis/UG/n2_z/95.00'] = {'max': -0.75517261, 'min': -0.99903888} # lost: 43
limits['SS_cis/UG/n2_z/99.00'] = {'max': -0.70178896, 'min': -0.99903888} # lost: 8
limits['SS_cis/UG/n2_z/99.50'] = {'max': -0.69729048, 'min': -0.99903888} # lost: 4
limits['SS_cis/UG/n2_z/99.90'] = {'max': -0.59160465, 'min': -0.99903888} # lost: 0
limits['SS_cis/UG/n2_z/99.99'] = {'max': -0.59160465, 'min': -0.99903888} # lost: 0
limits['SS_cis/UG/nn_ang_norm/100.00'] = {'max': 58.032164519301745, 'min': 2.0858118201605009} # lost: 0
limits['SS_cis/UG/nn_ang_norm/95.00'] = {'max': 40.801318451030426, 'min': 2.0858118201605009} # lost: 43
limits['SS_cis/UG/nn_ang_norm/99.00'] = {'max': 45.48479282528649, 'min': 2.0858118201605009} # lost: 8
limits['SS_cis/UG/nn_ang_norm/99.50'] = {'max': 46.880719567097032, 'min': 2.0858118201605009} # lost: 4
limits['SS_cis/UG/nn_ang_norm/99.90'] = {'max': 58.032164519301745, 'min': 2.0858118201605009} # lost: 0
limits['SS_cis/UG/nn_ang_norm/99.99'] = {'max': 58.032164519301745, 'min': 2.0858118201605009} # lost: 0
limits['SS_cis/UG/rot_ang/100.00'] = {'max2': -50.998402458989915, 'min1': 245.26329559833903, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/UG/rot_ang/95.00'] = {'max2': -83.708079005306445, 'min1': 259.34402885166713, 'min2': -90.0, 'max1': 270.0} # lost: 43
limits['SS_cis/UG/rot_ang/99.00'] = {'max2': -76.391166719275532, 'min1': 252.53772224737585, 'min2': -90.0, 'max1': 270.0} # lost: 8
limits['SS_cis/UG/rot_ang/99.50'] = {'max2': -71.842245450427185, 'min1': 247.16648757075274, 'min2': -90.0, 'max1': 270.0} # lost: 4
limits['SS_cis/UG/rot_ang/99.90'] = {'max2': -50.998402458989915, 'min1': 245.26329559833903, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_cis/UG/rot_ang/99.99'] = {'max2': -50.998402458989915, 'min1': 245.26329559833903, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['SS_tran/AA/dist/100.00'] = {'max': 4.9981377255253472, 'min': 4.9876094437443923} # lost: 0
limits['SS_tran/AA/dist/95.00'] = {'max': 4.9981377255253472, 'min': 4.9876094437443923} # lost: 0
limits['SS_tran/AA/dist/99.00'] = {'max': 4.9981377255253472, 'min': 4.9876094437443923} # lost: 0
limits['SS_tran/AA/dist/99.50'] = {'max': 4.9981377255253472, 'min': 4.9876094437443923} # lost: 0
limits['SS_tran/AA/dist/99.90'] = {'max': 4.9981377255253472, 'min': 4.9876094437443923} # lost: 0
limits['SS_tran/AA/dist/99.99'] = {'max': 4.9981377255253472, 'min': 4.9876094437443923} # lost: 0
limits['SS_tran/AA/min_dist/100.00'] = {'max': 1.6460213020862458, 'min': 1.6175203479331337} # lost: 0
limits['SS_tran/AA/min_dist/95.00'] = {'max': 1.6460213020862458, 'min': 1.6175203479331337} # lost: 0
limits['SS_tran/AA/min_dist/99.00'] = {'max': 1.6460213020862458, 'min': 1.6175203479331337} # lost: 0
limits['SS_tran/AA/min_dist/99.50'] = {'max': 1.6460213020862458, 'min': 1.6175203479331337} # lost: 0
limits['SS_tran/AA/min_dist/99.90'] = {'max': 1.6460213020862458, 'min': 1.6175203479331337} # lost: 0
limits['SS_tran/AA/min_dist/99.99'] = {'max': 1.6460213020862458, 'min': 1.6175203479331337} # lost: 0
limits['SS_tran/AA/n2_z/100.00'] = {'max': 0.78425527, 'min': 0.781941} # lost: 0
limits['SS_tran/AA/n2_z/95.00'] = {'max': 0.78425527, 'min': 0.781941} # lost: 0
limits['SS_tran/AA/n2_z/99.00'] = {'max': 0.78425527, 'min': 0.781941} # lost: 0
limits['SS_tran/AA/n2_z/99.50'] = {'max': 0.78425527, 'min': 0.781941} # lost: 0
limits['SS_tran/AA/n2_z/99.90'] = {'max': 0.78425527, 'min': 0.781941} # lost: 0
limits['SS_tran/AA/n2_z/99.99'] = {'max': 0.78425527, 'min': 0.781941} # lost: 0
limits['SS_tran/AA/nn_ang_norm/100.00'] = {'max': 38.66533889141617, 'min': 38.329887810709337} # lost: 0
limits['SS_tran/AA/nn_ang_norm/95.00'] = {'max': 38.66533889141617, 'min': 38.329887810709337} # lost: 0
limits['SS_tran/AA/nn_ang_norm/99.00'] = {'max': 38.66533889141617, 'min': 38.329887810709337} # lost: 0
limits['SS_tran/AA/nn_ang_norm/99.50'] = {'max': 38.66533889141617, 'min': 38.329887810709337} # lost: 0
limits['SS_tran/AA/nn_ang_norm/99.90'] = {'max': 38.66533889141617, 'min': 38.329887810709337} # lost: 0
limits['SS_tran/AA/nn_ang_norm/99.99'] = {'max': 38.66533889141617, 'min': 38.329887810709337} # lost: 0
limits['SS_tran/AA/rot_ang/100.00'] = {'max': 196.63124201818948, 'min': 163.36875798181052} # lost: 0
limits['SS_tran/AA/rot_ang/95.00'] = {'max': 196.63124201818948, 'min': 163.36875798181052} # lost: 0
limits['SS_tran/AA/rot_ang/99.00'] = {'max': 196.63124201818948, 'min': 163.36875798181052} # lost: 0
limits['SS_tran/AA/rot_ang/99.50'] = {'max': 196.63124201818948, 'min': 163.36875798181052} # lost: 0
limits['SS_tran/AA/rot_ang/99.90'] = {'max': 196.63124201818948, 'min': 163.36875798181052} # lost: 0
limits['SS_tran/AA/rot_ang/99.99'] = {'max': 196.63124201818948, 'min': 163.36875798181052} # lost: 0
limits['SS_tran/AG/dist/100.00'] = {'max': 6.7353416744994661, 'min': 4.4251890062324986} # lost: 0
limits['SS_tran/AG/dist/95.00'] = {'max': 6.2105128369466014, 'min': 5.3108383730599016} # lost: 636
limits['SS_tran/AG/dist/99.00'] = {'max': 6.3997267102594027, 'min': 5.1499182044568164} # lost: 127
limits['SS_tran/AG/dist/99.50'] = {'max': 6.4682454526691124, 'min': 5.0783589861454459} # lost: 63
limits['SS_tran/AG/dist/99.90'] = {'max': 6.6345485653076839, 'min': 4.7655778401510505} # lost: 12
limits['SS_tran/AG/dist/99.99'] = {'max': 6.6838241970382972, 'min': 4.4251890062324986} # lost: 1
limits['SS_tran/AG/min_dist/100.00'] = {'max': 2.7187083195754158, 'min': 0.72377876221102577} # lost: 0
limits['SS_tran/AG/min_dist/95.00'] = {'max': 2.3996929558418252, 'min': 1.6332133608530637} # lost: 636
limits['SS_tran/AG/min_dist/99.00'] = {'max': 2.5014825121671524, 'min': 1.4989881979796589} # lost: 127
limits['SS_tran/AG/min_dist/99.50'] = {'max': 2.5352163390812175, 'min': 1.4473681696429253} # lost: 63
limits['SS_tran/AG/min_dist/99.90'] = {'max': 2.6872410524567369, 'min': 1.2824112982353366} # lost: 12
limits['SS_tran/AG/min_dist/99.99'] = {'max': 2.7040444875946092, 'min': 0.72377876221102577} # lost: 1
limits['SS_tran/AG/n2_z/100.00'] = {'max': 0.9999581, 'min': 0.41591617} # lost: 0
limits['SS_tran/AG/n2_z/95.00'] = {'max': 0.9999581, 'min': 0.64210939} # lost: 636
limits['SS_tran/AG/n2_z/99.00'] = {'max': 0.9999581, 'min': 0.53306937} # lost: 127
limits['SS_tran/AG/n2_z/99.50'] = {'max': 0.9999581, 'min': 0.49326178} # lost: 63
limits['SS_tran/AG/n2_z/99.90'] = {'max': 0.9999581, 'min': 0.44176748} # lost: 12
limits['SS_tran/AG/n2_z/99.99'] = {'max': 0.9999581, 'min': 0.42328534} # lost: 1
limits['SS_tran/AG/nn_ang_norm/100.00'] = {'max': 64.978021121675823, 'min': 0.2594431881582005} # lost: 0
limits['SS_tran/AG/nn_ang_norm/95.00'] = {'max': 50.172339586149661, 'min': 0.2594431881582005} # lost: 636
limits['SS_tran/AG/nn_ang_norm/99.00'] = {'max': 57.811492946364133, 'min': 0.2594431881582005} # lost: 127
limits['SS_tran/AG/nn_ang_norm/99.50'] = {'max': 60.298754143948472, 'min': 0.2594431881582005} # lost: 63
limits['SS_tran/AG/nn_ang_norm/99.90'] = {'max': 63.976974936540415, 'min': 0.2594431881582005} # lost: 12
limits['SS_tran/AG/nn_ang_norm/99.99'] = {'max': 64.754298275412054, 'min': 0.2594431881582005} # lost: 1
limits['SS_tran/AG/rot_ang/100.00'] = {'max': 235.56287975431542, 'min': 160.46893659812966} # lost: 0
limits['SS_tran/AG/rot_ang/95.00'] = {'max': 222.73863305395426, 'min': 194.58173439277192} # lost: 636
limits['SS_tran/AG/rot_ang/99.00'] = {'max': 227.01886272282024, 'min': 186.5201443257414} # lost: 127
limits['SS_tran/AG/rot_ang/99.50'] = {'max': 228.6924929178038, 'min': 184.47595964715703} # lost: 63
limits['SS_tran/AG/rot_ang/99.90'] = {'max': 230.4338400884233, 'min': 174.40927825798551} # lost: 12
limits['SS_tran/AG/rot_ang/99.99'] = {'max': 235.29384493441017, 'min': 160.46893659812966} # lost: 1
limits['SS_tran/CG/dist/100.00'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/CG/dist/95.00'] = {'max': 7.8624594886897903, 'min': 7.1105195647245836} # lost: 6
limits['SS_tran/CG/dist/99.00'] = {'max': 7.9117921809830758, 'min': 6.7654452491195567} # lost: 1
limits['SS_tran/CG/dist/99.50'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/CG/dist/99.90'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/CG/dist/99.99'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/CG/min_dist/100.00'] = {'max': 2.4976021189740836, 'min': 1.4010969062804941} # lost: 0
limits['SS_tran/CG/min_dist/95.00'] = {'max': 2.4390855878465034, 'min': 1.648390785945566} # lost: 6
limits['SS_tran/CG/min_dist/99.00'] = {'max': 2.4751684618048055, 'min': 1.4010969062804941} # lost: 1
limits['SS_tran/CG/min_dist/99.50'] = {'max': 2.4976021189740836, 'min': 1.4010969062804941} # lost: 0
limits['SS_tran/CG/min_dist/99.90'] = {'max': 2.4976021189740836, 'min': 1.4010969062804941} # lost: 0
limits['SS_tran/CG/min_dist/99.99'] = {'max': 2.4976021189740836, 'min': 1.4010969062804941} # lost: 0
limits['SS_tran/CG/n2_z/100.00'] = {'max': 0.95543754, 'min': 0.71800929} # lost: 0
limits['SS_tran/CG/n2_z/95.00'] = {'max': 0.95543754, 'min': 0.75647998} # lost: 6
limits['SS_tran/CG/n2_z/99.00'] = {'max': 0.95543754, 'min': 0.72535735} # lost: 1
limits['SS_tran/CG/n2_z/99.50'] = {'max': 0.95543754, 'min': 0.71800929} # lost: 0
limits['SS_tran/CG/n2_z/99.90'] = {'max': 0.95543754, 'min': 0.71800929} # lost: 0
limits['SS_tran/CG/n2_z/99.99'] = {'max': 0.95543754, 'min': 0.71800929} # lost: 0
limits['SS_tran/CG/nn_ang_norm/100.00'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/CG/nn_ang_norm/95.00'] = {'max': 40.987972039435689, 'min': 17.168494978885573} # lost: 6
limits['SS_tran/CG/nn_ang_norm/99.00'] = {'max': 43.050672093306616, 'min': 17.168494978885573} # lost: 1
limits['SS_tran/CG/nn_ang_norm/99.50'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/CG/nn_ang_norm/99.90'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/CG/nn_ang_norm/99.99'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/CG/rot_ang/100.00'] = {'max': 194.31722961956919, 'min': 165.23635039889558} # lost: 0
limits['SS_tran/CG/rot_ang/95.00'] = {'max': 194.30880997858856, 'min': 166.66020513206294} # lost: 6
limits['SS_tran/CG/rot_ang/99.00'] = {'max': 194.31429683188378, 'min': 165.23635039889558} # lost: 1
limits['SS_tran/CG/rot_ang/99.50'] = {'max': 194.31722961956919, 'min': 165.23635039889558} # lost: 0
limits['SS_tran/CG/rot_ang/99.90'] = {'max': 194.31722961956919, 'min': 165.23635039889558} # lost: 0
limits['SS_tran/CG/rot_ang/99.99'] = {'max': 194.31722961956919, 'min': 165.23635039889558} # lost: 0
limits['SS_tran/GA/dist/100.00'] = {'max': 6.7353416744994661, 'min': 4.4251890062324986} # lost: 0
limits['SS_tran/GA/dist/95.00'] = {'max': 6.2105128369466014, 'min': 5.3108383730599016} # lost: 636
limits['SS_tran/GA/dist/99.00'] = {'max': 6.3997267102594027, 'min': 5.1499182044568164} # lost: 127
limits['SS_tran/GA/dist/99.50'] = {'max': 6.4682454526691124, 'min': 5.0783589861454459} # lost: 63
limits['SS_tran/GA/dist/99.90'] = {'max': 6.6345485653076839, 'min': 4.7655778401510505} # lost: 12
limits['SS_tran/GA/dist/99.99'] = {'max': 6.6838241970382972, 'min': 4.4251890062324986} # lost: 1
limits['SS_tran/GA/min_dist/100.00'] = {'max': 2.718703955376061, 'min': 0.72378547739864529} # lost: 0
limits['SS_tran/GA/min_dist/95.00'] = {'max': 2.3996927796561094, 'min': 1.63320197831251} # lost: 636
limits['SS_tran/GA/min_dist/99.00'] = {'max': 2.5014939981303264, 'min': 1.4989774742401647} # lost: 127
limits['SS_tran/GA/min_dist/99.50'] = {'max': 2.5352157642205397, 'min': 1.4473664128524837} # lost: 63
limits['SS_tran/GA/min_dist/99.90'] = {'max': 2.6872397595159505, 'min': 1.2824198159819931} # lost: 12
limits['SS_tran/GA/min_dist/99.99'] = {'max': 2.7040335888123272, 'min': 0.72378547739864529} # lost: 1
limits['SS_tran/GA/n2_z/100.00'] = {'max': 0.99995804, 'min': 0.41591623} # lost: 0
limits['SS_tran/GA/n2_z/95.00'] = {'max': 0.99995804, 'min': 0.64210927} # lost: 636
limits['SS_tran/GA/n2_z/99.00'] = {'max': 0.99995804, 'min': 0.53306931} # lost: 127
limits['SS_tran/GA/n2_z/99.50'] = {'max': 0.99995804, 'min': 0.49326181} # lost: 63
limits['SS_tran/GA/n2_z/99.90'] = {'max': 0.99995804, 'min': 0.44176722} # lost: 12
limits['SS_tran/GA/n2_z/99.99'] = {'max': 0.99995804, 'min': 0.42328551} # lost: 1
limits['SS_tran/GA/nn_ang_norm/100.00'] = {'max': 64.978021121675823, 'min': 0.2594431881582005} # lost: 0
limits['SS_tran/GA/nn_ang_norm/95.00'] = {'max': 50.172339586149661, 'min': 0.2594431881582005} # lost: 636
limits['SS_tran/GA/nn_ang_norm/99.00'] = {'max': 57.811492946364133, 'min': 0.2594431881582005} # lost: 127
limits['SS_tran/GA/nn_ang_norm/99.50'] = {'max': 60.298754143948472, 'min': 0.2594431881582005} # lost: 63
limits['SS_tran/GA/nn_ang_norm/99.90'] = {'max': 63.976974936540415, 'min': 0.2594431881582005} # lost: 12
limits['SS_tran/GA/nn_ang_norm/99.99'] = {'max': 64.754298275412054, 'min': 0.2594431881582005} # lost: 1
limits['SS_tran/GA/rot_ang/100.00'] = {'max': 199.53106340187034, 'min': 124.4371202456846} # lost: 0
limits['SS_tran/GA/rot_ang/95.00'] = {'max': 165.41826560722808, 'min': 137.26136694604574} # lost: 636
limits['SS_tran/GA/rot_ang/99.00'] = {'max': 173.46455181147698, 'min': 132.96289940045989} # lost: 127
limits['SS_tran/GA/rot_ang/99.50'] = {'max': 175.5193225974343, 'min': 131.27044769996832} # lost: 63
limits['SS_tran/GA/rot_ang/99.90'] = {'max': 185.59072174201449, 'min': 129.5661599115767} # lost: 12
limits['SS_tran/GA/rot_ang/99.99'] = {'max': 195.25930415196089, 'min': 124.4371202456846} # lost: 1
limits['SS_tran/GC/dist/100.00'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/GC/dist/95.00'] = {'max': 7.8624594886897903, 'min': 7.1105195647245836} # lost: 6
limits['SS_tran/GC/dist/99.00'] = {'max': 7.9117921809830758, 'min': 6.7654452491195567} # lost: 1
limits['SS_tran/GC/dist/99.50'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/GC/dist/99.90'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/GC/dist/99.99'] = {'max': 7.9304873899059931, 'min': 6.7654452491195567} # lost: 0
limits['SS_tran/GC/min_dist/100.00'] = {'max': 2.4975995121891983, 'min': 1.40108313488216} # lost: 0
limits['SS_tran/GC/min_dist/95.00'] = {'max': 2.4390697605340432, 'min': 1.6483878061888364} # lost: 6
limits['SS_tran/GC/min_dist/99.00'] = {'max': 2.4751711858395629, 'min': 1.40108313488216} # lost: 1
limits['SS_tran/GC/min_dist/99.50'] = {'max': 2.4975995121891983, 'min': 1.40108313488216} # lost: 0
limits['SS_tran/GC/min_dist/99.90'] = {'max': 2.4975995121891983, 'min': 1.40108313488216} # lost: 0
limits['SS_tran/GC/min_dist/99.99'] = {'max': 2.4975995121891983, 'min': 1.40108313488216} # lost: 0
limits['SS_tran/GC/n2_z/100.00'] = {'max': 0.95543742, 'min': 0.71800941} # lost: 0
limits['SS_tran/GC/n2_z/95.00'] = {'max': 0.95543742, 'min': 0.75647998} # lost: 6
limits['SS_tran/GC/n2_z/99.00'] = {'max': 0.95543742, 'min': 0.72535717} # lost: 1
limits['SS_tran/GC/n2_z/99.50'] = {'max': 0.95543742, 'min': 0.71800941} # lost: 0
limits['SS_tran/GC/n2_z/99.90'] = {'max': 0.95543742, 'min': 0.71800941} # lost: 0
limits['SS_tran/GC/n2_z/99.99'] = {'max': 0.95543742, 'min': 0.71800941} # lost: 0
limits['SS_tran/GC/nn_ang_norm/100.00'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/GC/nn_ang_norm/95.00'] = {'max': 40.987972039435689, 'min': 17.168494978885573} # lost: 6
limits['SS_tran/GC/nn_ang_norm/99.00'] = {'max': 43.050672093306616, 'min': 17.168494978885573} # lost: 1
limits['SS_tran/GC/nn_ang_norm/99.50'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/GC/nn_ang_norm/99.90'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/GC/nn_ang_norm/99.99'] = {'max': 46.616252821201293, 'min': 17.168494978885573} # lost: 0
limits['SS_tran/GC/rot_ang/100.00'] = {'max': 194.76364960110442, 'min': 165.68277038043081} # lost: 0
limits['SS_tran/GC/rot_ang/95.00'] = {'max': 193.33979486793706, 'min': 165.69119002141144} # lost: 6
limits['SS_tran/GC/rot_ang/99.00'] = {'max': 194.08349690690176, 'min': 165.68277038043081} # lost: 1
limits['SS_tran/GC/rot_ang/99.50'] = {'max': 194.76364960110442, 'min': 165.68277038043081} # lost: 0
limits['SS_tran/GC/rot_ang/99.90'] = {'max': 194.76364960110442, 'min': 165.68277038043081} # lost: 0
limits['SS_tran/GC/rot_ang/99.99'] = {'max': 194.76364960110442, 'min': 165.68277038043081} # lost: 0
limits['SS_tran/GG/dist/100.00'] = {'max': 7.2706369756261369, 'min': 5.144991466006914} # lost: 0
limits['SS_tran/GG/dist/95.00'] = {'max': 6.6841742343051251, 'min': 5.7745809929026066} # lost: 139
limits['SS_tran/GG/dist/99.00'] = {'max': 6.9132967565343248, 'min': 5.5776309194380156} # lost: 27
limits['SS_tran/GG/dist/99.50'] = {'max': 7.1308249340009748, 'min': 5.4081418353189736} # lost: 13
limits['SS_tran/GG/dist/99.90'] = {'max': 7.2706369756261369, 'min': 5.144991466006914} # lost: 2
limits['SS_tran/GG/dist/99.99'] = {'max': 7.2706369756261369, 'min': 5.144991466006914} # lost: 0
limits['SS_tran/GG/min_dist/100.00'] = {'max': 3.0283185783518158, 'min': 1.1501226855176057} # lost: 0
limits['SS_tran/GG/min_dist/95.00'] = {'max': 2.4538580444755236, 'min': 1.5425558051006516} # lost: 139
limits['SS_tran/GG/min_dist/99.00'] = {'max': 2.6504935627384145, 'min': 1.3569381208776843} # lost: 27
limits['SS_tran/GG/min_dist/99.50'] = {'max': 2.9306944180646997, 'min': 1.3269087351670283} # lost: 13
limits['SS_tran/GG/min_dist/99.90'] = {'max': 3.0283094859038622, 'min': 1.1501352069268374} # lost: 2
limits['SS_tran/GG/min_dist/99.99'] = {'max': 3.0283185783518158, 'min': 1.1501226855176057} # lost: 0
limits['SS_tran/GG/n2_z/100.00'] = {'max': 0.99839091, 'min': 0.44448307} # lost: 0
limits['SS_tran/GG/n2_z/95.00'] = {'max': 0.99839091, 'min': 0.63021082} # lost: 139
limits['SS_tran/GG/n2_z/99.00'] = {'max': 0.99839091, 'min': 0.54555202} # lost: 27
limits['SS_tran/GG/n2_z/99.50'] = {'max': 0.99839091, 'min': 0.52119672} # lost: 13
limits['SS_tran/GG/n2_z/99.90'] = {'max': 0.99839091, 'min': 0.46681696} # lost: 2
limits['SS_tran/GG/n2_z/99.99'] = {'max': 0.99839091, 'min': 0.44448307} # lost: 0
limits['SS_tran/GG/nn_ang_norm/100.00'] = {'max': 63.671296650425667, 'min': 3.3065963897104882} # lost: 0
limits['SS_tran/GG/nn_ang_norm/95.00'] = {'max': 51.242497040401844, 'min': 3.3065963897104882} # lost: 139
limits['SS_tran/GG/nn_ang_norm/99.00'] = {'max': 57.778031849620241, 'min': 3.3065963897104882} # lost: 27
limits['SS_tran/GG/nn_ang_norm/99.50'] = {'max': 58.94953223568249, 'min': 3.3065963897104882} # lost: 13
limits['SS_tran/GG/nn_ang_norm/99.90'] = {'max': 63.578214832416734, 'min': 3.3065963897104882} # lost: 2
limits['SS_tran/GG/nn_ang_norm/99.99'] = {'max': 63.671296650425667, 'min': 3.3065963897104882} # lost: 0
limits['SS_tran/GG/rot_ang/100.00'] = {'max': 209.06686934812453, 'min': 150.93313065187547} # lost: 0
limits['SS_tran/GG/rot_ang/95.00'] = {'max': 196.16018588687689, 'min': 163.58307485490477} # lost: 139
limits['SS_tran/GG/rot_ang/99.00'] = {'max': 202.8844454813111, 'min': 156.99730246338922} # lost: 27
limits['SS_tran/GG/rot_ang/99.50'] = {'max': 205.41721192900641, 'min': 153.59457148081279} # lost: 13
limits['SS_tran/GG/rot_ang/99.90'] = {'max': 208.11093847925082, 'min': 151.88906152074918} # lost: 2
limits['SS_tran/GG/rot_ang/99.99'] = {'max': 209.06686934812453, 'min': 150.93313065187547} # lost: 0
limits['SS_tran/GU/dist/100.00'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/GU/dist/95.00'] = {'max': 7.8407861398126713, 'min': 6.905324408092941} # lost: 4
limits['SS_tran/GU/dist/99.00'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/GU/dist/99.50'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/GU/dist/99.90'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/GU/dist/99.99'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/GU/min_dist/100.00'] = {'max': 2.4029667300208484, 'min': 1.6571535620818547} # lost: 0
limits['SS_tran/GU/min_dist/95.00'] = {'max': 2.3530121651830789, 'min': 1.7422760685396981} # lost: 4
limits['SS_tran/GU/min_dist/99.00'] = {'max': 2.4029667300208484, 'min': 1.6571535620818547} # lost: 0
limits['SS_tran/GU/min_dist/99.50'] = {'max': 2.4029667300208484, 'min': 1.6571535620818547} # lost: 0
limits['SS_tran/GU/min_dist/99.90'] = {'max': 2.4029667300208484, 'min': 1.6571535620818547} # lost: 0
limits['SS_tran/GU/min_dist/99.99'] = {'max': 2.4029667300208484, 'min': 1.6571535620818547} # lost: 0
limits['SS_tran/GU/n2_z/100.00'] = {'max': 0.98182529, 'min': 0.72590274} # lost: 0
limits['SS_tran/GU/n2_z/95.00'] = {'max': 0.98182529, 'min': 0.84120208} # lost: 4
limits['SS_tran/GU/n2_z/99.00'] = {'max': 0.98182529, 'min': 0.72590274} # lost: 0
limits['SS_tran/GU/n2_z/99.50'] = {'max': 0.98182529, 'min': 0.72590274} # lost: 0
limits['SS_tran/GU/n2_z/99.90'] = {'max': 0.98182529, 'min': 0.72590274} # lost: 0
limits['SS_tran/GU/n2_z/99.99'] = {'max': 0.98182529, 'min': 0.72590274} # lost: 0
limits['SS_tran/GU/nn_ang_norm/100.00'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/GU/nn_ang_norm/95.00'] = {'max': 34.359700336761442, 'min': 12.808634967504695} # lost: 4
limits['SS_tran/GU/nn_ang_norm/99.00'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/GU/nn_ang_norm/99.50'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/GU/nn_ang_norm/99.90'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/GU/nn_ang_norm/99.99'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/GU/rot_ang/100.00'] = {'max': 203.63444581207409, 'min': 153.66164656285747} # lost: 0
limits['SS_tran/GU/rot_ang/95.00'] = {'max': 202.93793571308203, 'min': 160.21873608412054} # lost: 4
limits['SS_tran/GU/rot_ang/99.00'] = {'max': 203.63444581207409, 'min': 153.66164656285747} # lost: 0
limits['SS_tran/GU/rot_ang/99.50'] = {'max': 203.63444581207409, 'min': 153.66164656285747} # lost: 0
limits['SS_tran/GU/rot_ang/99.90'] = {'max': 203.63444581207409, 'min': 153.66164656285747} # lost: 0
limits['SS_tran/GU/rot_ang/99.99'] = {'max': 203.63444581207409, 'min': 153.66164656285747} # lost: 0
limits['SS_tran/UG/dist/100.00'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/UG/dist/95.00'] = {'max': 7.8407861398126713, 'min': 6.905324408092941} # lost: 4
limits['SS_tran/UG/dist/99.00'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/UG/dist/99.50'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/UG/dist/99.90'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/UG/dist/99.99'] = {'max': 7.9653574961363551, 'min': 6.3897131896979067} # lost: 0
limits['SS_tran/UG/min_dist/100.00'] = {'max': 2.4029668863685454, 'min': 1.6571422108525189} # lost: 0
limits['SS_tran/UG/min_dist/95.00'] = {'max': 2.3530013921718864, 'min': 1.7422728954960025} # lost: 4
limits['SS_tran/UG/min_dist/99.00'] = {'max': 2.4029668863685454, 'min': 1.6571422108525189} # lost: 0
limits['SS_tran/UG/min_dist/99.50'] = {'max': 2.4029668863685454, 'min': 1.6571422108525189} # lost: 0
limits['SS_tran/UG/min_dist/99.90'] = {'max': 2.4029668863685454, 'min': 1.6571422108525189} # lost: 0
limits['SS_tran/UG/min_dist/99.99'] = {'max': 2.4029668863685454, 'min': 1.6571422108525189} # lost: 0
limits['SS_tran/UG/n2_z/100.00'] = {'max': 0.98182529, 'min': 0.7259028} # lost: 0
limits['SS_tran/UG/n2_z/95.00'] = {'max': 0.98182529, 'min': 0.84120208} # lost: 4
limits['SS_tran/UG/n2_z/99.00'] = {'max': 0.98182529, 'min': 0.7259028} # lost: 0
limits['SS_tran/UG/n2_z/99.50'] = {'max': 0.98182529, 'min': 0.7259028} # lost: 0
limits['SS_tran/UG/n2_z/99.90'] = {'max': 0.98182529, 'min': 0.7259028} # lost: 0
limits['SS_tran/UG/n2_z/99.99'] = {'max': 0.98182529, 'min': 0.7259028} # lost: 0
limits['SS_tran/UG/nn_ang_norm/100.00'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/UG/nn_ang_norm/95.00'] = {'max': 34.359700336761442, 'min': 12.808634967504695} # lost: 4
limits['SS_tran/UG/nn_ang_norm/99.00'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/UG/nn_ang_norm/99.50'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/UG/nn_ang_norm/99.90'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/UG/nn_ang_norm/99.99'] = {'max': 44.313888259543795, 'min': 12.808634967504695} # lost: 0
limits['SS_tran/UG/rot_ang/100.00'] = {'max': 206.33835343714253, 'min': 156.36555418792591} # lost: 0
limits['SS_tran/UG/rot_ang/95.00'] = {'max': 199.78126391587946, 'min': 157.06206428691797} # lost: 4
limits['SS_tran/UG/rot_ang/99.00'] = {'max': 206.33835343714253, 'min': 156.36555418792591} # lost: 0
limits['SS_tran/UG/rot_ang/99.50'] = {'max': 206.33835343714253, 'min': 156.36555418792591} # lost: 0
limits['SS_tran/UG/rot_ang/99.90'] = {'max': 206.33835343714253, 'min': 156.36555418792591} # lost: 0
limits['SS_tran/UG/rot_ang/99.99'] = {'max': 206.33835343714253, 'min': 156.36555418792591} # lost: 0
limits['SW_cis/AA/dist/100.00'] = {'max': 7.4255924863873135, 'min': 4.4335114541928649} # lost: 0
limits['SW_cis/AA/dist/95.00'] = {'max': 7.1694772586882447, 'min': 6.2024663838415739} # lost: 72
limits['SW_cis/AA/dist/99.00'] = {'max': 7.2683443096103959, 'min': 5.8590972608083876} # lost: 14
limits['SW_cis/AA/dist/99.50'] = {'max': 7.3178979161985325, 'min': 5.2823017040658051} # lost: 7
limits['SW_cis/AA/dist/99.90'] = {'max': 7.368408688668298, 'min': 4.4335114541928649} # lost: 1
limits['SW_cis/AA/dist/99.99'] = {'max': 7.4255924863873135, 'min': 4.4335114541928649} # lost: 0
limits['SW_cis/AA/min_dist/100.00'] = {'max': 2.7312727363084055, 'min': 1.1887854144993151} # lost: 0
limits['SW_cis/AA/min_dist/95.00'] = {'max': 2.5412483765044103, 'min': 1.7567043470096728} # lost: 72
limits['SW_cis/AA/min_dist/99.00'] = {'max': 2.6702428921124932, 'min': 1.5356544487687194} # lost: 14
limits['SW_cis/AA/min_dist/99.50'] = {'max': 2.7019855347924993, 'min': 1.4573279132561203} # lost: 7
limits['SW_cis/AA/min_dist/99.90'] = {'max': 2.7282789503857443, 'min': 1.1887854144993151} # lost: 1
limits['SW_cis/AA/min_dist/99.99'] = {'max': 2.7312727363084055, 'min': 1.1887854144993151} # lost: 0
limits['SW_cis/AA/n2_z/100.00'] = {'max': -0.45555472, 'min': -0.99997634} # lost: 0
limits['SW_cis/AA/n2_z/95.00'] = {'max': -0.74369818, 'min': -0.99997634} # lost: 72
limits['SW_cis/AA/n2_z/99.00'] = {'max': -0.61306441, 'min': -0.99997634} # lost: 14
limits['SW_cis/AA/n2_z/99.50'] = {'max': -0.56522948, 'min': -0.99997634} # lost: 7
limits['SW_cis/AA/n2_z/99.90'] = {'max': -0.45557642, 'min': -0.99997634} # lost: 1
limits['SW_cis/AA/n2_z/99.99'] = {'max': -0.45555472, 'min': -0.99997634} # lost: 0
limits['SW_cis/AA/nn_ang_norm/100.00'] = {'max': 63.540220311296792, 'min': 0.31090520206265637} # lost: 0
limits['SW_cis/AA/nn_ang_norm/95.00'] = {'max': 42.017829783723045, 'min': 0.31090520206265637} # lost: 72
limits['SW_cis/AA/nn_ang_norm/99.00'] = {'max': 52.24900236791693, 'min': 0.31090520206265637} # lost: 14
limits['SW_cis/AA/nn_ang_norm/99.50'] = {'max': 55.68721031307463, 'min': 0.31090520206265637} # lost: 7
limits['SW_cis/AA/nn_ang_norm/99.90'] = {'max': 62.625125226676815, 'min': 0.31090520206265637} # lost: 1
limits['SW_cis/AA/nn_ang_norm/99.99'] = {'max': 63.540220311296792, 'min': 0.31090520206265637} # lost: 0
limits['SW_cis/AA/rot_ang/100.00'] = {'max': 65.90603320393619, 'min': -64.485632004671203} # lost: 0
limits['SW_cis/AA/rot_ang/95.00'] = {'max': 51.065395465049669, 'min': 13.477793118452745} # lost: 72
limits['SW_cis/AA/rot_ang/99.00'] = {'max': 58.706354175549265, 'min': -37.294849861049705} # lost: 14
limits['SW_cis/AA/rot_ang/99.50'] = {'max': 65.865818892568484, 'min': -53.98451477673288} # lost: 7
limits['SW_cis/AA/rot_ang/99.90'] = {'max': 65.902051971697261, 'min': -64.485632004671203} # lost: 1
limits['SW_cis/AA/rot_ang/99.99'] = {'max': 65.90603320393619, 'min': -64.485632004671203} # lost: 0
limits['SW_cis/AC/dist/100.00'] = {'max': 7.3304593213565159, 'min': 5.8829997943081693} # lost: 0
limits['SW_cis/AC/dist/95.00'] = {'max': 7.1192200388800346, 'min': 6.4077709153851492} # lost: 32
limits['SW_cis/AC/dist/99.00'] = {'max': 7.2969193794531186, 'min': 6.271886276047792} # lost: 6
limits['SW_cis/AC/dist/99.50'] = {'max': 7.3152688821318783, 'min': 5.8953640200944877} # lost: 3
limits['SW_cis/AC/dist/99.90'] = {'max': 7.3304593213565159, 'min': 5.8829997943081693} # lost: 0
limits['SW_cis/AC/dist/99.99'] = {'max': 7.3304593213565159, 'min': 5.8829997943081693} # lost: 0
limits['SW_cis/AC/min_dist/100.00'] = {'max': 2.7779113609181705, 'min': 1.7633444639555191} # lost: 0
limits['SW_cis/AC/min_dist/95.00'] = {'max': 2.5666925804653968, 'min': 1.9054184840523489} # lost: 32
limits['SW_cis/AC/min_dist/99.00'] = {'max': 2.705148451875484, 'min': 1.8310527885638685} # lost: 6
limits['SW_cis/AC/min_dist/99.50'] = {'max': 2.7130462295050553, 'min': 1.7836676642209561} # lost: 3
limits['SW_cis/AC/min_dist/99.90'] = {'max': 2.7779113609181705, 'min': 1.7633444639555191} # lost: 0
limits['SW_cis/AC/min_dist/99.99'] = {'max': 2.7779113609181705, 'min': 1.7633444639555191} # lost: 0
limits['SW_cis/AC/n2_z/100.00'] = {'max': -0.43140617, 'min': -0.99944931} # lost: 0
limits['SW_cis/AC/n2_z/95.00'] = {'max': -0.63770378, 'min': -0.99944931} # lost: 32
limits['SW_cis/AC/n2_z/99.00'] = {'max': -0.48563758, 'min': -0.99944931} # lost: 6
limits['SW_cis/AC/n2_z/99.50'] = {'max': -0.47581378, 'min': -0.99944931} # lost: 3
limits['SW_cis/AC/n2_z/99.90'] = {'max': -0.43140617, 'min': -0.99944931} # lost: 0
limits['SW_cis/AC/n2_z/99.99'] = {'max': -0.43140617, 'min': -0.99944931} # lost: 0
limits['SW_cis/AC/nn_ang_norm/100.00'] = {'max': 64.525898570799669, 'min': 1.9910497756157497} # lost: 0
limits['SW_cis/AC/nn_ang_norm/95.00'] = {'max': 50.289393774283582, 'min': 1.9910497756157497} # lost: 32
limits['SW_cis/AC/nn_ang_norm/99.00'] = {'max': 61.282009507528826, 'min': 1.9910497756157497} # lost: 6
limits['SW_cis/AC/nn_ang_norm/99.50'] = {'max': 61.868695436476244, 'min': 1.9910497756157497} # lost: 3
limits['SW_cis/AC/nn_ang_norm/99.90'] = {'max': 64.525898570799669, 'min': 1.9910497756157497} # lost: 0
limits['SW_cis/AC/nn_ang_norm/99.99'] = {'max': 64.525898570799669, 'min': 1.9910497756157497} # lost: 0
limits['SW_cis/AC/rot_ang/100.00'] = {'max': 64.491657721469608, 'min': -62.794953370458117} # lost: 0
limits['SW_cis/AC/rot_ang/95.00'] = {'max': 51.54436879386796, 'min': -50.529338180883727} # lost: 32
limits['SW_cis/AC/rot_ang/99.00'] = {'max': 61.399590569938674, 'min': -59.35182373466764} # lost: 6
limits['SW_cis/AC/rot_ang/99.50'] = {'max': 61.715868577071099, 'min': -61.800740638450115} # lost: 3
limits['SW_cis/AC/rot_ang/99.90'] = {'max': 64.491657721469608, 'min': -62.794953370458117} # lost: 0
limits['SW_cis/AC/rot_ang/99.99'] = {'max': 64.491657721469608, 'min': -62.794953370458117} # lost: 0
limits['SW_cis/AG/dist/100.00'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['SW_cis/AG/dist/95.00'] = {'max': 6.1097414547671862, 'min': 5.0681236259283864} # lost: 5
limits['SW_cis/AG/dist/99.00'] = {'max': 6.2759909865586465, 'min': 4.9404726868995228} # lost: 1
limits['SW_cis/AG/dist/99.50'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['SW_cis/AG/dist/99.90'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['SW_cis/AG/dist/99.99'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['SW_cis/AG/min_dist/100.00'] = {'max': 2.5367685787570493, 'min': 0.70248982042326125} # lost: 0
limits['SW_cis/AG/min_dist/95.00'] = {'max': 2.428225200288304, 'min': 1.1911221879931211} # lost: 5
limits['SW_cis/AG/min_dist/99.00'] = {'max': 2.5009194614299881, 'min': 0.70248982042326125} # lost: 1
limits['SW_cis/AG/min_dist/99.50'] = {'max': 2.5367685787570493, 'min': 0.70248982042326125} # lost: 0
limits['SW_cis/AG/min_dist/99.90'] = {'max': 2.5367685787570493, 'min': 0.70248982042326125} # lost: 0
limits['SW_cis/AG/min_dist/99.99'] = {'max': 2.5367685787570493, 'min': 0.70248982042326125} # lost: 0
limits['SW_cis/AG/n2_z/100.00'] = {'max': -0.4363645, 'min': -0.9719789} # lost: 0
limits['SW_cis/AG/n2_z/95.00'] = {'max': -0.50921524, 'min': -0.9719789} # lost: 5
limits['SW_cis/AG/n2_z/99.00'] = {'max': -0.49162373, 'min': -0.9719789} # lost: 1
limits['SW_cis/AG/n2_z/99.50'] = {'max': -0.4363645, 'min': -0.9719789} # lost: 0
limits['SW_cis/AG/n2_z/99.90'] = {'max': -0.4363645, 'min': -0.9719789} # lost: 0
limits['SW_cis/AG/n2_z/99.99'] = {'max': -0.4363645, 'min': -0.9719789} # lost: 0
limits['SW_cis/AG/nn_ang_norm/100.00'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['SW_cis/AG/nn_ang_norm/95.00'] = {'max': 58.994893343193382, 'min': 13.532730755859973} # lost: 5
limits['SW_cis/AG/nn_ang_norm/99.00'] = {'max': 60.39450838715571, 'min': 13.532730755859973} # lost: 1
limits['SW_cis/AG/nn_ang_norm/99.50'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['SW_cis/AG/nn_ang_norm/99.90'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['SW_cis/AG/nn_ang_norm/99.99'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['SW_cis/AG/rot_ang/100.00'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['SW_cis/AG/rot_ang/95.00'] = {'max': 54.540552381035567, 'min': -67.834571085319595} # lost: 5
limits['SW_cis/AG/rot_ang/99.00'] = {'max': 55.140029611418463, 'min': -69.515159579358496} # lost: 1
limits['SW_cis/AG/rot_ang/99.50'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['SW_cis/AG/rot_ang/99.90'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['SW_cis/AG/rot_ang/99.99'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['SW_cis/AU/dist/100.00'] = {'max': 6.082101045099586, 'min': 5.1819624823719135} # lost: 0
limits['SW_cis/AU/dist/95.00'] = {'max': 5.9242437624755482, 'min': 5.3271240884879765} # lost: 34
limits['SW_cis/AU/dist/99.00'] = {'max': 6.047960664031244, 'min': 5.225379670041213} # lost: 6
limits['SW_cis/AU/dist/99.50'] = {'max': 6.0567038492091001, 'min': 5.1930159834229173} # lost: 3
limits['SW_cis/AU/dist/99.90'] = {'max': 6.082101045099586, 'min': 5.1819624823719135} # lost: 0
limits['SW_cis/AU/dist/99.99'] = {'max': 6.082101045099586, 'min': 5.1819624823719135} # lost: 0
limits['SW_cis/AU/min_dist/100.00'] = {'max': 2.527121168910976, 'min': 1.5337162008700909} # lost: 0
limits['SW_cis/AU/min_dist/95.00'] = {'max': 2.3489057394081194, 'min': 1.7309388817138807} # lost: 34
limits['SW_cis/AU/min_dist/99.00'] = {'max': 2.514650212921584, 'min': 1.6346273341589221} # lost: 6
limits['SW_cis/AU/min_dist/99.50'] = {'max': 2.5176961067193955, 'min': 1.6085237714627805} # lost: 3
limits['SW_cis/AU/min_dist/99.90'] = {'max': 2.527121168910976, 'min': 1.5337162008700909} # lost: 0
limits['SW_cis/AU/min_dist/99.99'] = {'max': 2.527121168910976, 'min': 1.5337162008700909} # lost: 0
limits['SW_cis/AU/n2_z/100.00'] = {'max': -0.58227032, 'min': -0.9990052} # lost: 0
limits['SW_cis/AU/n2_z/95.00'] = {'max': -0.74270952, 'min': -0.9990052} # lost: 34
limits['SW_cis/AU/n2_z/99.00'] = {'max': -0.6513992, 'min': -0.9990052} # lost: 6
limits['SW_cis/AU/n2_z/99.50'] = {'max': -0.63583606, 'min': -0.9990052} # lost: 3
limits['SW_cis/AU/n2_z/99.90'] = {'max': -0.58227032, 'min': -0.9990052} # lost: 0
limits['SW_cis/AU/n2_z/99.99'] = {'max': -0.58227032, 'min': -0.9990052} # lost: 0
limits['SW_cis/AU/nn_ang_norm/100.00'] = {'max': 52.453457250532082, 'min': 5.0285032014121214} # lost: 0
limits['SW_cis/AU/nn_ang_norm/95.00'] = {'max': 42.305271464753872, 'min': 5.0285032014121214} # lost: 34
limits['SW_cis/AU/nn_ang_norm/99.00'] = {'max': 49.929756993725732, 'min': 5.0285032014121214} # lost: 6
limits['SW_cis/AU/nn_ang_norm/99.50'] = {'max': 51.419202685652067, 'min': 5.0285032014121214} # lost: 3
limits['SW_cis/AU/nn_ang_norm/99.90'] = {'max': 52.453457250532082, 'min': 5.0285032014121214} # lost: 0
limits['SW_cis/AU/nn_ang_norm/99.99'] = {'max': 52.453457250532082, 'min': 5.0285032014121214} # lost: 0
limits['SW_cis/AU/rot_ang/100.00'] = {'max': 49.585379296094551, 'min': -66.000619466056918} # lost: 0
limits['SW_cis/AU/rot_ang/95.00'] = {'max': -20.410940738870288, 'min': -55.164968956719569} # lost: 34
limits['SW_cis/AU/rot_ang/99.00'] = {'max': -16.198729584632396, 'min': -59.622656565465256} # lost: 6
limits['SW_cis/AU/rot_ang/99.50'] = {'max': 7.2649581329931392, 'min': -64.925860775204583} # lost: 3
limits['SW_cis/AU/rot_ang/99.90'] = {'max': 49.585379296094551, 'min': -66.000619466056918} # lost: 0
limits['SW_cis/AU/rot_ang/99.99'] = {'max': 49.585379296094551, 'min': -66.000619466056918} # lost: 0
limits['SW_cis/CA/dist/100.00'] = {'max': 8.2618641635859245, 'min': 6.0458700554917071} # lost: 0
limits['SW_cis/CA/dist/95.00'] = {'max': 7.8750312780340996, 'min': 6.8831735173044883} # lost: 103
limits['SW_cis/CA/dist/99.00'] = {'max': 8.0664424900058016, 'min': 6.6586824767919843} # lost: 20
limits['SW_cis/CA/dist/99.50'] = {'max': 8.1623993182714258, 'min': 6.3370383140674313} # lost: 10
limits['SW_cis/CA/dist/99.90'] = {'max': 8.2013781901452223, 'min': 6.0823199351927428} # lost: 2
limits['SW_cis/CA/dist/99.99'] = {'max': 8.2618641635859245, 'min': 6.0458700554917071} # lost: 0
limits['SW_cis/CA/min_dist/100.00'] = {'max': 2.8549808379518873, 'min': 1.215108848163146} # lost: 0
limits['SW_cis/CA/min_dist/95.00'] = {'max': 2.489096842359281, 'min': 1.534454469310907} # lost: 103
limits['SW_cis/CA/min_dist/99.00'] = {'max': 2.6192504568793993, 'min': 1.3931259792811681} # lost: 20
limits['SW_cis/CA/min_dist/99.50'] = {'max': 2.6562913200732319, 'min': 1.2873173497033741} # lost: 10
limits['SW_cis/CA/min_dist/99.90'] = {'max': 2.7163733371833456, 'min': 1.2158024679183699} # lost: 2
limits['SW_cis/CA/min_dist/99.99'] = {'max': 2.8549808379518873, 'min': 1.215108848163146} # lost: 0
limits['SW_cis/CA/n2_z/100.00'] = {'max': -0.44495335, 'min': -0.99957335} # lost: 0
limits['SW_cis/CA/n2_z/95.00'] = {'max': -0.66896683, 'min': -0.99957335} # lost: 103
limits['SW_cis/CA/n2_z/99.00'] = {'max': -0.6161347, 'min': -0.99957335} # lost: 20
limits['SW_cis/CA/n2_z/99.50'] = {'max': -0.58748418, 'min': -0.99957335} # lost: 10
limits['SW_cis/CA/n2_z/99.90'] = {'max': -0.52695227, 'min': -0.99957335} # lost: 2
limits['SW_cis/CA/n2_z/99.99'] = {'max': -0.44495335, 'min': -0.99957335} # lost: 0
limits['SW_cis/CA/nn_ang_norm/100.00'] = {'max': 64.50792151290419, 'min': 2.6241263494058842} # lost: 0
limits['SW_cis/CA/nn_ang_norm/95.00'] = {'max': 47.769545744169136, 'min': 2.6241263494058842} # lost: 103
limits['SW_cis/CA/nn_ang_norm/99.00'] = {'max': 51.985179481036027, 'min': 2.6241263494058842} # lost: 20
limits['SW_cis/CA/nn_ang_norm/99.50'] = {'max': 53.702562245944023, 'min': 2.6241263494058842} # lost: 10
limits['SW_cis/CA/nn_ang_norm/99.90'] = {'max': 58.125847393957642, 'min': 2.6241263494058842} # lost: 2
limits['SW_cis/CA/nn_ang_norm/99.99'] = {'max': 64.50792151290419, 'min': 2.6241263494058842} # lost: 0
limits['SW_cis/CA/rot_ang/100.00'] = {'max': 71.835721154875415, 'min': -57.834821599327078} # lost: 0
limits['SW_cis/CA/rot_ang/95.00'] = {'max': 52.418345868365158, 'min': 18.198734076357866} # lost: 103
limits['SW_cis/CA/rot_ang/99.00'] = {'max': 57.921020905340754, 'min': -28.691598225434532} # lost: 20
limits['SW_cis/CA/rot_ang/99.50'] = {'max': 63.548896386553146, 'min': -42.041803185768288} # lost: 10
limits['SW_cis/CA/rot_ang/99.90'] = {'max': 68.937197383354274, 'min': -56.566193795769443} # lost: 2
limits['SW_cis/CA/rot_ang/99.99'] = {'max': 71.835721154875415, 'min': -57.834821599327078} # lost: 0
limits['SW_cis/CC/dist/100.00'] = {'max': 7.9979517391589772, 'min': 6.1214010002377064} # lost: 0
limits['SW_cis/CC/dist/95.00'] = {'max': 7.7654422146638939, 'min': 6.8891440671523068} # lost: 37
limits['SW_cis/CC/dist/99.00'] = {'max': 7.8541859567789398, 'min': 6.6590340711254887} # lost: 7
limits['SW_cis/CC/dist/99.50'] = {'max': 7.8937072330897529, 'min': 6.3191579929995738} # lost: 3
limits['SW_cis/CC/dist/99.90'] = {'max': 7.9979517391589772, 'min': 6.1214010002377064} # lost: 0
limits['SW_cis/CC/dist/99.99'] = {'max': 7.9979517391589772, 'min': 6.1214010002377064} # lost: 0
limits['SW_cis/CC/min_dist/100.00'] = {'max': 2.5777611189367207, 'min': 1.3118413515225003} # lost: 0
limits['SW_cis/CC/min_dist/95.00'] = {'max': 2.3858299958954245, 'min': 1.5679779214666123} # lost: 37
limits['SW_cis/CC/min_dist/99.00'] = {'max': 2.496815359194851, 'min': 1.442089154827604} # lost: 7
limits['SW_cis/CC/min_dist/99.50'] = {'max': 2.5521961811088718, 'min': 1.3471007605706851} # lost: 3
limits['SW_cis/CC/min_dist/99.90'] = {'max': 2.5777611189367207, 'min': 1.3118413515225003} # lost: 0
limits['SW_cis/CC/min_dist/99.99'] = {'max': 2.5777611189367207, 'min': 1.3118413515225003} # lost: 0
limits['SW_cis/CC/n2_z/100.00'] = {'max': -0.4446674, 'min': -0.99465472} # lost: 0
limits['SW_cis/CC/n2_z/95.00'] = {'max': -0.54137683, 'min': -0.99465472} # lost: 37
limits['SW_cis/CC/n2_z/99.00'] = {'max': -0.4667623, 'min': -0.99465472} # lost: 7
limits['SW_cis/CC/n2_z/99.50'] = {'max': -0.45653903, 'min': -0.99465472} # lost: 3
limits['SW_cis/CC/n2_z/99.90'] = {'max': -0.4446674, 'min': -0.99465472} # lost: 0
limits['SW_cis/CC/n2_z/99.99'] = {'max': -0.4446674, 'min': -0.99465472} # lost: 0
limits['SW_cis/CC/nn_ang_norm/100.00'] = {'max': 63.672739641573372, 'min': 11.760009798296522} # lost: 0
limits['SW_cis/CC/nn_ang_norm/95.00'] = {'max': 57.27938205011796, 'min': 11.760009798296522} # lost: 37
limits['SW_cis/CC/nn_ang_norm/99.00'] = {'max': 62.299256901375514, 'min': 11.760009798296522} # lost: 7
limits['SW_cis/CC/nn_ang_norm/99.50'] = {'max': 62.958752646875254, 'min': 11.760009798296522} # lost: 3
limits['SW_cis/CC/nn_ang_norm/99.90'] = {'max': 63.672739641573372, 'min': 11.760009798296522} # lost: 0
limits['SW_cis/CC/nn_ang_norm/99.99'] = {'max': 63.672739641573372, 'min': 11.760009798296522} # lost: 0
limits['SW_cis/CC/rot_ang/100.00'] = {'max': 63.598389002161994, 'min': -63.761090978915703} # lost: 0
limits['SW_cis/CC/rot_ang/95.00'] = {'max': 58.075407374948369, 'min': -56.783151765859216} # lost: 37
limits['SW_cis/CC/rot_ang/99.00'] = {'max': 62.320412602551954, 'min': -62.364292760376706} # lost: 7
limits['SW_cis/CC/rot_ang/99.50'] = {'max': 63.038223941574394, 'min': -63.115741024895485} # lost: 3
limits['SW_cis/CC/rot_ang/99.90'] = {'max': 63.598389002161994, 'min': -63.761090978915703} # lost: 0
limits['SW_cis/CC/rot_ang/99.99'] = {'max': 63.598389002161994, 'min': -63.761090978915703} # lost: 0
limits['SW_cis/CG/dist/100.00'] = {'max': 7.202403511159214, 'min': 5.7623016963608471} # lost: 0
limits['SW_cis/CG/dist/95.00'] = {'max': 6.9828070521518155, 'min': 5.9216044548680671} # lost: 13
limits['SW_cis/CG/dist/99.00'] = {'max': 7.1221959556895573, 'min': 5.7947999333995046} # lost: 2
limits['SW_cis/CG/dist/99.50'] = {'max': 7.1221959556895573, 'min': 5.7623016963608471} # lost: 1
limits['SW_cis/CG/dist/99.90'] = {'max': 7.202403511159214, 'min': 5.7623016963608471} # lost: 0
limits['SW_cis/CG/dist/99.99'] = {'max': 7.202403511159214, 'min': 5.7623016963608471} # lost: 0
limits['SW_cis/CG/min_dist/100.00'] = {'max': 2.4250099382914359, 'min': 1.3382652183953434} # lost: 0
limits['SW_cis/CG/min_dist/95.00'] = {'max': 2.2748240476790778, 'min': 1.5183208668880104} # lost: 13
limits['SW_cis/CG/min_dist/99.00'] = {'max': 2.3891606483630583, 'min': 1.4484536940760644} # lost: 2
limits['SW_cis/CG/min_dist/99.50'] = {'max': 2.3891606483630583, 'min': 1.3382652183953434} # lost: 1
limits['SW_cis/CG/min_dist/99.90'] = {'max': 2.4250099382914359, 'min': 1.3382652183953434} # lost: 0
limits['SW_cis/CG/min_dist/99.99'] = {'max': 2.4250099382914359, 'min': 1.3382652183953434} # lost: 0
limits['SW_cis/CG/n2_z/100.00'] = {'max': -0.46228233, 'min': -0.99344271} # lost: 0
limits['SW_cis/CG/n2_z/95.00'] = {'max': -0.7758286, 'min': -0.99344271} # lost: 13
limits['SW_cis/CG/n2_z/99.00'] = {'max': -0.46256107, 'min': -0.99344271} # lost: 2
limits['SW_cis/CG/n2_z/99.50'] = {'max': -0.46256107, 'min': -0.99344271} # lost: 1
limits['SW_cis/CG/n2_z/99.90'] = {'max': -0.46228233, 'min': -0.99344271} # lost: 0
limits['SW_cis/CG/n2_z/99.99'] = {'max': -0.46228233, 'min': -0.99344271} # lost: 0
limits['SW_cis/CG/nn_ang_norm/100.00'] = {'max': 62.555061146170829, 'min': 6.0955836554431926} # lost: 0
limits['SW_cis/CG/nn_ang_norm/95.00'] = {'max': 39.158739917912385, 'min': 6.0955836554431926} # lost: 13
limits['SW_cis/CG/nn_ang_norm/99.00'] = {'max': 62.5045040859344, 'min': 6.0955836554431926} # lost: 2
limits['SW_cis/CG/nn_ang_norm/99.50'] = {'max': 62.5045040859344, 'min': 6.0955836554431926} # lost: 1
limits['SW_cis/CG/nn_ang_norm/99.90'] = {'max': 62.555061146170829, 'min': 6.0955836554431926} # lost: 0
limits['SW_cis/CG/nn_ang_norm/99.99'] = {'max': 62.555061146170829, 'min': 6.0955836554431926} # lost: 0
limits['SW_cis/CG/rot_ang/100.00'] = {'max': 54.071337425454885, 'min': -66.74993170020403} # lost: 0
limits['SW_cis/CG/rot_ang/95.00'] = {'max': 42.434999222811697, 'min': -38.850154216277588} # lost: 13
limits['SW_cis/CG/rot_ang/99.00'] = {'max': 50.102170499891294, 'min': -66.734381066495843} # lost: 2
limits['SW_cis/CG/rot_ang/99.50'] = {'max': 50.102170499891294, 'min': -66.74993170020403} # lost: 1
limits['SW_cis/CG/rot_ang/99.90'] = {'max': 54.071337425454885, 'min': -66.74993170020403} # lost: 0
limits['SW_cis/CG/rot_ang/99.99'] = {'max': 54.071337425454885, 'min': -66.74993170020403} # lost: 0
limits['SW_cis/CU/dist/100.00'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['SW_cis/CU/dist/95.00'] = {'max': 6.7777908828735294, 'min': 5.8837054383083176} # lost: 3
limits['SW_cis/CU/dist/99.00'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['SW_cis/CU/dist/99.50'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['SW_cis/CU/dist/99.90'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['SW_cis/CU/dist/99.99'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['SW_cis/CU/min_dist/100.00'] = {'max': 2.3539718999568717, 'min': 1.4675770965221078} # lost: 0
limits['SW_cis/CU/min_dist/95.00'] = {'max': 2.24220763141706, 'min': 1.5001258508903281} # lost: 3
limits['SW_cis/CU/min_dist/99.00'] = {'max': 2.3539718999568717, 'min': 1.4675770965221078} # lost: 0
limits['SW_cis/CU/min_dist/99.50'] = {'max': 2.3539718999568717, 'min': 1.4675770965221078} # lost: 0
limits['SW_cis/CU/min_dist/99.90'] = {'max': 2.3539718999568717, 'min': 1.4675770965221078} # lost: 0
limits['SW_cis/CU/min_dist/99.99'] = {'max': 2.3539718999568717, 'min': 1.4675770965221078} # lost: 0
limits['SW_cis/CU/n2_z/100.00'] = {'max': -0.43348515, 'min': -0.9721638} # lost: 0
limits['SW_cis/CU/n2_z/95.00'] = {'max': -0.44524178, 'min': -0.9721638} # lost: 3
limits['SW_cis/CU/n2_z/99.00'] = {'max': -0.43348515, 'min': -0.9721638} # lost: 0
limits['SW_cis/CU/n2_z/99.50'] = {'max': -0.43348515, 'min': -0.9721638} # lost: 0
limits['SW_cis/CU/n2_z/99.90'] = {'max': -0.43348515, 'min': -0.9721638} # lost: 0
limits['SW_cis/CU/n2_z/99.99'] = {'max': -0.43348515, 'min': -0.9721638} # lost: 0
limits['SW_cis/CU/nn_ang_norm/100.00'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['SW_cis/CU/nn_ang_norm/95.00'] = {'max': 63.56707661511328, 'min': 13.648010688671434} # lost: 3
limits['SW_cis/CU/nn_ang_norm/99.00'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['SW_cis/CU/nn_ang_norm/99.50'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['SW_cis/CU/nn_ang_norm/99.90'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['SW_cis/CU/nn_ang_norm/99.99'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['SW_cis/CU/rot_ang/100.00'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['SW_cis/CU/rot_ang/95.00'] = {'max': -24.464540683235242, 'min': -85.270814190973198} # lost: 3
limits['SW_cis/CU/rot_ang/99.00'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['SW_cis/CU/rot_ang/99.50'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['SW_cis/CU/rot_ang/99.90'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['SW_cis/CU/rot_ang/99.99'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['SW_cis/GA/dist/100.00'] = {'max': 7.4417061192036495, 'min': 5.1457438504154585} # lost: 0
limits['SW_cis/GA/dist/95.00'] = {'max': 6.9509609592783006, 'min': 5.5073869330281155} # lost: 47
limits['SW_cis/GA/dist/99.00'] = {'max': 7.2750173456155878, 'min': 5.3831965356664551} # lost: 9
limits['SW_cis/GA/dist/99.50'] = {'max': 7.3158081780381918, 'min': 5.3267885075455297} # lost: 4
limits['SW_cis/GA/dist/99.90'] = {'max': 7.4417061192036495, 'min': 5.1457438504154585} # lost: 0
limits['SW_cis/GA/dist/99.99'] = {'max': 7.4417061192036495, 'min': 5.1457438504154585} # lost: 0
limits['SW_cis/GA/min_dist/100.00'] = {'max': 2.5519617133320316, 'min': 0.81775038991242976} # lost: 0
limits['SW_cis/GA/min_dist/95.00'] = {'max': 2.4279917061698679, 'min': 1.4165618178638357} # lost: 47
limits['SW_cis/GA/min_dist/99.00'] = {'max': 2.5129247775443146, 'min': 1.0584174592954845} # lost: 9
limits['SW_cis/GA/min_dist/99.50'] = {'max': 2.5427556503566193, 'min': 1.0200138645065853} # lost: 4
limits['SW_cis/GA/min_dist/99.90'] = {'max': 2.5519617133320316, 'min': 0.81775038991242976} # lost: 0
limits['SW_cis/GA/min_dist/99.99'] = {'max': 2.5519617133320316, 'min': 0.81775038991242976} # lost: 0
limits['SW_cis/GA/n2_z/100.00'] = {'max': -0.42700109, 'min': -0.99991143} # lost: 0
limits['SW_cis/GA/n2_z/95.00'] = {'max': -0.49270356, 'min': -0.99991143} # lost: 47
limits['SW_cis/GA/n2_z/99.00'] = {'max': -0.44119468, 'min': -0.99991143} # lost: 9
limits['SW_cis/GA/n2_z/99.50'] = {'max': -0.4318096, 'min': -0.99991143} # lost: 4
limits['SW_cis/GA/n2_z/99.90'] = {'max': -0.42700109, 'min': -0.99991143} # lost: 0
limits['SW_cis/GA/n2_z/99.99'] = {'max': -0.42700109, 'min': -0.99991143} # lost: 0
limits['SW_cis/GA/nn_ang_norm/100.00'] = {'max': 64.840893234942314, 'min': 0.60035495870945965} # lost: 0
limits['SW_cis/GA/nn_ang_norm/95.00'] = {'max': 60.808445171615162, 'min': 0.60035495870945965} # lost: 47
limits['SW_cis/GA/nn_ang_norm/99.00'] = {'max': 63.896701544458097, 'min': 0.60035495870945965} # lost: 9
limits['SW_cis/GA/nn_ang_norm/99.50'] = {'max': 64.626876087489137, 'min': 0.60035495870945965} # lost: 4
limits['SW_cis/GA/nn_ang_norm/99.90'] = {'max': 64.840893234942314, 'min': 0.60035495870945965} # lost: 0
limits['SW_cis/GA/nn_ang_norm/99.99'] = {'max': 64.840893234942314, 'min': 0.60035495870945965} # lost: 0
limits['SW_cis/GA/rot_ang/100.00'] = {'max': 60.300978611678197, 'min': -85.243668408411537} # lost: 0
limits['SW_cis/GA/rot_ang/95.00'] = {'max': 56.444941815542457, 'min': -80.10933978244816} # lost: 47
limits['SW_cis/GA/rot_ang/99.00'] = {'max': 58.23830781261583, 'min': -82.672465696914855} # lost: 9
limits['SW_cis/GA/rot_ang/99.50'] = {'max': 59.367917237200686, 'min': -83.964691158067993} # lost: 4
limits['SW_cis/GA/rot_ang/99.90'] = {'max': 60.300978611678197, 'min': -85.243668408411537} # lost: 0
limits['SW_cis/GA/rot_ang/99.99'] = {'max': 60.300978611678197, 'min': -85.243668408411537} # lost: 0
limits['SW_cis/GC/dist/100.00'] = {'max': 7.3152364839789499, 'min': 5.9824775167726134} # lost: 0
limits['SW_cis/GC/dist/95.00'] = {'max': 7.1981421000817418, 'min': 6.1527476520445896} # lost: 11
limits['SW_cis/GC/dist/99.00'] = {'max': 7.2713645315353537, 'min': 6.0505312748880842} # lost: 2
limits['SW_cis/GC/dist/99.50'] = {'max': 7.2713645315353537, 'min': 5.9824775167726134} # lost: 1
limits['SW_cis/GC/dist/99.90'] = {'max': 7.3152364839789499, 'min': 5.9824775167726134} # lost: 0
limits['SW_cis/GC/dist/99.99'] = {'max': 7.3152364839789499, 'min': 5.9824775167726134} # lost: 0
limits['SW_cis/GC/min_dist/100.00'] = {'max': 2.488901412271519, 'min': 1.0136125772914448} # lost: 0
limits['SW_cis/GC/min_dist/95.00'] = {'max': 2.4052297429682037, 'min': 1.4434360901786272} # lost: 11
limits['SW_cis/GC/min_dist/99.00'] = {'max': 2.4647228599306472, 'min': 1.2609747327364325} # lost: 2
limits['SW_cis/GC/min_dist/99.50'] = {'max': 2.4647228599306472, 'min': 1.0136125772914448} # lost: 1
limits['SW_cis/GC/min_dist/99.90'] = {'max': 2.488901412271519, 'min': 1.0136125772914448} # lost: 0
limits['SW_cis/GC/min_dist/99.99'] = {'max': 2.488901412271519, 'min': 1.0136125772914448} # lost: 0
limits['SW_cis/GC/n2_z/100.00'] = {'max': -0.46673402, 'min': -0.99324632} # lost: 0
limits['SW_cis/GC/n2_z/95.00'] = {'max': -0.56513977, 'min': -0.99324632} # lost: 11
limits['SW_cis/GC/n2_z/99.00'] = {'max': -0.47279298, 'min': -0.99324632} # lost: 2
limits['SW_cis/GC/n2_z/99.50'] = {'max': -0.47095314, 'min': -0.99324632} # lost: 1
limits['SW_cis/GC/n2_z/99.90'] = {'max': -0.46673402, 'min': -0.99324632} # lost: 0
limits['SW_cis/GC/n2_z/99.99'] = {'max': -0.46673402, 'min': -0.99324632} # lost: 0
limits['SW_cis/GC/nn_ang_norm/100.00'] = {'max': 62.211038178055631, 'min': 6.7891757052796606} # lost: 0
limits['SW_cis/GC/nn_ang_norm/95.00'] = {'max': 55.86513674095346, 'min': 6.7891757052796606} # lost: 11
limits['SW_cis/GC/nn_ang_norm/99.00'] = {'max': 62.116549341077672, 'min': 6.7891757052796606} # lost: 2
limits['SW_cis/GC/nn_ang_norm/99.50'] = {'max': 62.168062627797909, 'min': 6.7891757052796606} # lost: 1
limits['SW_cis/GC/nn_ang_norm/99.90'] = {'max': 62.211038178055631, 'min': 6.7891757052796606} # lost: 0
limits['SW_cis/GC/nn_ang_norm/99.99'] = {'max': 62.211038178055631, 'min': 6.7891757052796606} # lost: 0
limits['SW_cis/GC/rot_ang/100.00'] = {'max': 62.195025540245467, 'min': -67.799708073611711} # lost: 0
limits['SW_cis/GC/rot_ang/95.00'] = {'max': 56.921428190845305, 'min': -62.170295459248379} # lost: 11
limits['SW_cis/GC/rot_ang/99.00'] = {'max': 62.178405471965618, 'min': -65.452272416716028} # lost: 2
limits['SW_cis/GC/rot_ang/99.50'] = {'max': 62.178405471965618, 'min': -67.799708073611711} # lost: 1
limits['SW_cis/GC/rot_ang/99.90'] = {'max': 62.195025540245467, 'min': -67.799708073611711} # lost: 0
limits['SW_cis/GC/rot_ang/99.99'] = {'max': 62.195025540245467, 'min': -67.799708073611711} # lost: 0
limits['SW_cis/GG/dist/100.00'] = {'max': 7.3776015269020121, 'min': 4.8782614611193313} # lost: 0
limits['SW_cis/GG/dist/95.00'] = {'max': 7.3205115253157915, 'min': 5.091811240414275} # lost: 10
limits['SW_cis/GG/dist/99.00'] = {'max': 7.3396624430038306, 'min': 4.9557988554557824} # lost: 2
limits['SW_cis/GG/dist/99.50'] = {'max': 7.3396624430038306, 'min': 4.8782614611193313} # lost: 1
limits['SW_cis/GG/dist/99.90'] = {'max': 7.3776015269020121, 'min': 4.8782614611193313} # lost: 0
limits['SW_cis/GG/dist/99.99'] = {'max': 7.3776015269020121, 'min': 4.8782614611193313} # lost: 0
limits['SW_cis/GG/min_dist/100.00'] = {'max': 2.4463052848311984, 'min': 0.49812752891442946} # lost: 0
limits['SW_cis/GG/min_dist/95.00'] = {'max': 2.2992985377141211, 'min': 1.2799594729567056} # lost: 10
limits['SW_cis/GG/min_dist/99.00'] = {'max': 2.3530841577065775, 'min': 0.72395915867348892} # lost: 2
limits['SW_cis/GG/min_dist/99.50'] = {'max': 2.3530841577065775, 'min': 0.49812752891442946} # lost: 1
limits['SW_cis/GG/min_dist/99.90'] = {'max': 2.4463052848311984, 'min': 0.49812752891442946} # lost: 0
limits['SW_cis/GG/min_dist/99.99'] = {'max': 2.4463052848311984, 'min': 0.49812752891442946} # lost: 0
limits['SW_cis/GG/n2_z/100.00'] = {'max': -0.42347565, 'min': -0.99894094} # lost: 0
limits['SW_cis/GG/n2_z/95.00'] = {'max': -0.64240044, 'min': -0.99894094} # lost: 10
limits['SW_cis/GG/n2_z/99.00'] = {'max': -0.44912395, 'min': -0.99894094} # lost: 2
limits['SW_cis/GG/n2_z/99.50'] = {'max': -0.43900988, 'min': -0.99894094} # lost: 1
limits['SW_cis/GG/n2_z/99.90'] = {'max': -0.42347565, 'min': -0.99894094} # lost: 0
limits['SW_cis/GG/n2_z/99.99'] = {'max': -0.42347565, 'min': -0.99894094} # lost: 0
limits['SW_cis/GG/nn_ang_norm/100.00'] = {'max': 64.88982471015629, 'min': 2.6029391026005158} # lost: 0
limits['SW_cis/GG/nn_ang_norm/95.00'] = {'max': 50.101713836269965, 'min': 2.6029391026005158} # lost: 10
limits['SW_cis/GG/nn_ang_norm/99.00'] = {'max': 62.45756702595807, 'min': 2.6029391026005158} # lost: 2
limits['SW_cis/GG/nn_ang_norm/99.50'] = {'max': 63.998512344226299, 'min': 2.6029391026005158} # lost: 1
limits['SW_cis/GG/nn_ang_norm/99.90'] = {'max': 64.88982471015629, 'min': 2.6029391026005158} # lost: 0
limits['SW_cis/GG/nn_ang_norm/99.99'] = {'max': 64.88982471015629, 'min': 2.6029391026005158} # lost: 0
limits['SW_cis/GG/rot_ang/100.00'] = {'max': 65.109359526728085, 'min': -65.108987016171014} # lost: 0
limits['SW_cis/GG/rot_ang/95.00'] = {'max': 50.857558907105719, 'min': -53.035222238755779} # lost: 10
limits['SW_cis/GG/rot_ang/99.00'] = {'max': 63.959269742958973, 'min': -62.845890676480181} # lost: 2
limits['SW_cis/GG/rot_ang/99.50'] = {'max': 63.959269742958973, 'min': -65.108987016171014} # lost: 1
limits['SW_cis/GG/rot_ang/99.90'] = {'max': 65.109359526728085, 'min': -65.108987016171014} # lost: 0
limits['SW_cis/GG/rot_ang/99.99'] = {'max': 65.109359526728085, 'min': -65.108987016171014} # lost: 0
limits['SW_cis/GU/dist/100.00'] = {'max': 7.2656572727775286, 'min': 5.1118656397957469} # lost: 0
limits['SW_cis/GU/dist/95.00'] = {'max': 6.8420421749787614, 'min': 5.5738972776348188} # lost: 29
limits['SW_cis/GU/dist/99.00'] = {'max': 6.9903680019817571, 'min': 5.3121293744702651} # lost: 5
limits['SW_cis/GU/dist/99.50'] = {'max': 7.1562409149949326, 'min': 5.2621126218394441} # lost: 2
limits['SW_cis/GU/dist/99.90'] = {'max': 7.2656572727775286, 'min': 5.1118656397957469} # lost: 0
limits['SW_cis/GU/dist/99.99'] = {'max': 7.2656572727775286, 'min': 5.1118656397957469} # lost: 0
limits['SW_cis/GU/min_dist/100.00'] = {'max': 2.5665976214572526, 'min': 1.3209905060097269} # lost: 0
limits['SW_cis/GU/min_dist/95.00'] = {'max': 2.4147938852279389, 'min': 1.5299092370401666} # lost: 29
limits['SW_cis/GU/min_dist/99.00'] = {'max': 2.5167335136668774, 'min': 1.3432189069145135} # lost: 5
limits['SW_cis/GU/min_dist/99.50'] = {'max': 2.5405592289483252, 'min': 1.3238285276977508} # lost: 2
limits['SW_cis/GU/min_dist/99.90'] = {'max': 2.5665976214572526, 'min': 1.3209905060097269} # lost: 0
limits['SW_cis/GU/min_dist/99.99'] = {'max': 2.5665976214572526, 'min': 1.3209905060097269} # lost: 0
limits['SW_cis/GU/n2_z/100.00'] = {'max': -0.43479964, 'min': -0.98447943} # lost: 0
limits['SW_cis/GU/n2_z/95.00'] = {'max': -0.58780509, 'min': -0.98447943} # lost: 29
limits['SW_cis/GU/n2_z/99.00'] = {'max': -0.50016719, 'min': -0.98447943} # lost: 5
limits['SW_cis/GU/n2_z/99.50'] = {'max': -0.45450684, 'min': -0.98447943} # lost: 2
limits['SW_cis/GU/n2_z/99.90'] = {'max': -0.43479964, 'min': -0.98447943} # lost: 0
limits['SW_cis/GU/n2_z/99.99'] = {'max': -0.43479964, 'min': -0.98447943} # lost: 0
limits['SW_cis/GU/nn_ang_norm/100.00'] = {'max': 64.815389308581487, 'min': 8.6940744836611827} # lost: 0
limits['SW_cis/GU/nn_ang_norm/95.00'] = {'max': 54.044344912011454, 'min': 8.6940744836611827} # lost: 29
limits['SW_cis/GU/nn_ang_norm/99.00'] = {'max': 61.786323355085898, 'min': 8.6940744836611827} # lost: 5
limits['SW_cis/GU/nn_ang_norm/99.50'] = {'max': 64.220343228089973, 'min': 8.6940744836611827} # lost: 2
limits['SW_cis/GU/nn_ang_norm/99.90'] = {'max': 64.815389308581487, 'min': 8.6940744836611827} # lost: 0
limits['SW_cis/GU/nn_ang_norm/99.99'] = {'max': 64.815389308581487, 'min': 8.6940744836611827} # lost: 0
limits['SW_cis/GU/rot_ang/100.00'] = {'max': 55.141907533819385, 'min': -77.182883712551501} # lost: 0
limits['SW_cis/GU/rot_ang/95.00'] = {'max': -25.218028291180179, 'min': -67.83294735696191} # lost: 29
limits['SW_cis/GU/rot_ang/99.00'] = {'max': 42.590120835657949, 'min': -76.955947275861334} # lost: 5
limits['SW_cis/GU/rot_ang/99.50'] = {'max': 54.536636208693743, 'min': -77.165412703734532} # lost: 2
limits['SW_cis/GU/rot_ang/99.90'] = {'max': 55.141907533819385, 'min': -77.182883712551501} # lost: 0
limits['SW_cis/GU/rot_ang/99.99'] = {'max': 55.141907533819385, 'min': -77.182883712551501} # lost: 0
limits['SW_cis/UA/dist/100.00'] = {'max': 8.0744492328050725, 'min': 6.1877693990454459} # lost: 0
limits['SW_cis/UA/dist/95.00'] = {'max': 7.9019237034845942, 'min': 6.6237073698129629} # lost: 37
limits['SW_cis/UA/dist/99.00'] = {'max': 8.0192582386311884, 'min': 6.3883696485230077} # lost: 7
limits['SW_cis/UA/dist/99.50'] = {'max': 8.0370934551417683, 'min': 6.3528703843683614} # lost: 3
limits['SW_cis/UA/dist/99.90'] = {'max': 8.0744492328050725, 'min': 6.1877693990454459} # lost: 0
limits['SW_cis/UA/dist/99.99'] = {'max': 8.0744492328050725, 'min': 6.1877693990454459} # lost: 0
limits['SW_cis/UA/min_dist/100.00'] = {'max': 2.6901874172003097, 'min': 1.2644330522827398} # lost: 0
limits['SW_cis/UA/min_dist/95.00'] = {'max': 2.4827288490364094, 'min': 1.5669486667359309} # lost: 37
limits['SW_cis/UA/min_dist/99.00'] = {'max': 2.5868209442807895, 'min': 1.5004333831719716} # lost: 7
limits['SW_cis/UA/min_dist/99.50'] = {'max': 2.6346162196990712, 'min': 1.3215333553478359} # lost: 3
limits['SW_cis/UA/min_dist/99.90'] = {'max': 2.6901874172003097, 'min': 1.2644330522827398} # lost: 0
limits['SW_cis/UA/min_dist/99.99'] = {'max': 2.6901874172003097, 'min': 1.2644330522827398} # lost: 0
limits['SW_cis/UA/n2_z/100.00'] = {'max': -0.42901519, 'min': -0.9993279} # lost: 0
limits['SW_cis/UA/n2_z/95.00'] = {'max': -0.64688975, 'min': -0.9993279} # lost: 37
limits['SW_cis/UA/n2_z/99.00'] = {'max': -0.60051781, 'min': -0.9993279} # lost: 7
limits['SW_cis/UA/n2_z/99.50'] = {'max': -0.5159235, 'min': -0.9993279} # lost: 3
limits['SW_cis/UA/n2_z/99.90'] = {'max': -0.42901519, 'min': -0.9993279} # lost: 0
limits['SW_cis/UA/n2_z/99.99'] = {'max': -0.42901519, 'min': -0.9993279} # lost: 0
limits['SW_cis/UA/nn_ang_norm/100.00'] = {'max': 64.817943799331076, 'min': 2.4823043014797292} # lost: 0
limits['SW_cis/UA/nn_ang_norm/95.00'] = {'max': 50.052727719542645, 'min': 2.4823043014797292} # lost: 37
limits['SW_cis/UA/nn_ang_norm/99.00'] = {'max': 55.396080329892001, 'min': 2.4823043014797292} # lost: 7
limits['SW_cis/UA/nn_ang_norm/99.50'] = {'max': 58.982380436633917, 'min': 2.4823043014797292} # lost: 3
limits['SW_cis/UA/nn_ang_norm/99.90'] = {'max': 64.817943799331076, 'min': 2.4823043014797292} # lost: 0
limits['SW_cis/UA/nn_ang_norm/99.99'] = {'max': 64.817943799331076, 'min': 2.4823043014797292} # lost: 0
limits['SW_cis/UA/rot_ang/100.00'] = {'max': 76.66419499098842, 'min': -66.406237988413523} # lost: 0
limits['SW_cis/UA/rot_ang/95.00'] = {'max': 57.965172759699811, 'min': 15.688936330490804} # lost: 37
limits['SW_cis/UA/rot_ang/99.00'] = {'max': 62.847182636260712, 'min': -47.097212406152501} # lost: 7
limits['SW_cis/UA/rot_ang/99.50'] = {'max': 66.731150287281238, 'min': -52.529855541130509} # lost: 3
limits['SW_cis/UA/rot_ang/99.90'] = {'max': 76.66419499098842, 'min': -66.406237988413523} # lost: 0
limits['SW_cis/UA/rot_ang/99.99'] = {'max': 76.66419499098842, 'min': -66.406237988413523} # lost: 0
limits['SW_cis/UC/dist/100.00'] = {'max': 8.1096766331055044, 'min': 6.7276160736303963} # lost: 0
limits['SW_cis/UC/dist/95.00'] = {'max': 7.8412828597955144, 'min': 6.938823778174485} # lost: 12
limits['SW_cis/UC/dist/99.00'] = {'max': 7.9667725491751034, 'min': 6.8128860032124408} # lost: 2
limits['SW_cis/UC/dist/99.50'] = {'max': 7.9667725491751034, 'min': 6.7276160736303963} # lost: 1
limits['SW_cis/UC/dist/99.90'] = {'max': 8.1096766331055044, 'min': 6.7276160736303963} # lost: 0
limits['SW_cis/UC/dist/99.99'] = {'max': 8.1096766331055044, 'min': 6.7276160736303963} # lost: 0
limits['SW_cis/UC/min_dist/100.00'] = {'max': 2.6720657910609158, 'min': 1.5415068473652282} # lost: 0
limits['SW_cis/UC/min_dist/95.00'] = {'max': 2.5431080528259007, 'min': 1.5956517904280332} # lost: 12
limits['SW_cis/UC/min_dist/99.00'] = {'max': 2.6472733032844356, 'min': 1.5459514399154042} # lost: 2
limits['SW_cis/UC/min_dist/99.50'] = {'max': 2.6472733032844356, 'min': 1.5415068473652282} # lost: 1
limits['SW_cis/UC/min_dist/99.90'] = {'max': 2.6720657910609158, 'min': 1.5415068473652282} # lost: 0
limits['SW_cis/UC/min_dist/99.99'] = {'max': 2.6720657910609158, 'min': 1.5415068473652282} # lost: 0
limits['SW_cis/UC/n2_z/100.00'] = {'max': -0.48048159, 'min': -0.99644554} # lost: 0
limits['SW_cis/UC/n2_z/95.00'] = {'max': -0.71064287, 'min': -0.99644554} # lost: 12
limits['SW_cis/UC/n2_z/99.00'] = {'max': -0.53614283, 'min': -0.99644554} # lost: 2
limits['SW_cis/UC/n2_z/99.50'] = {'max': -0.49618036, 'min': -0.99644554} # lost: 1
limits['SW_cis/UC/n2_z/99.90'] = {'max': -0.48048159, 'min': -0.99644554} # lost: 0
limits['SW_cis/UC/n2_z/99.99'] = {'max': -0.48048159, 'min': -0.99644554} # lost: 0
limits['SW_cis/UC/nn_ang_norm/100.00'] = {'max': 60.517561075242668, 'min': 4.5331915431811183} # lost: 0
limits['SW_cis/UC/nn_ang_norm/95.00'] = {'max': 44.459977581839439, 'min': 4.5331915431811183} # lost: 12
limits['SW_cis/UC/nn_ang_norm/99.00'] = {'max': 59.123382861859668, 'min': 4.5331915431811183} # lost: 2
limits['SW_cis/UC/nn_ang_norm/99.50'] = {'max': 59.834023063864464, 'min': 4.5331915431811183} # lost: 1
limits['SW_cis/UC/nn_ang_norm/99.90'] = {'max': 60.517561075242668, 'min': 4.5331915431811183} # lost: 0
limits['SW_cis/UC/nn_ang_norm/99.99'] = {'max': 60.517561075242668, 'min': 4.5331915431811183} # lost: 0
limits['SW_cis/UC/rot_ang/100.00'] = {'max': 50.984405499660767, 'min': -62.157531935805721} # lost: 0
limits['SW_cis/UC/rot_ang/95.00'] = {'max': 45.774549439192583, 'min': -42.002497139098168} # lost: 12
limits['SW_cis/UC/rot_ang/99.00'] = {'max': 50.532318602584475, 'min': -61.364851989182029} # lost: 2
limits['SW_cis/UC/rot_ang/99.50'] = {'max': 50.532318602584475, 'min': -62.157531935805721} # lost: 1
limits['SW_cis/UC/rot_ang/99.90'] = {'max': 50.984405499660767, 'min': -62.157531935805721} # lost: 0
limits['SW_cis/UC/rot_ang/99.99'] = {'max': 50.984405499660767, 'min': -62.157531935805721} # lost: 0
limits['SW_cis/UG/dist/100.00'] = {'max': 7.3726289268682672, 'min': 5.2197275360409305} # lost: 0
limits['SW_cis/UG/dist/95.00'] = {'max': 7.0362203245488679, 'min': 6.0267426039710958} # lost: 21
limits['SW_cis/UG/dist/99.00'] = {'max': 7.1680617185046911, 'min': 5.9410914308316691} # lost: 4
limits['SW_cis/UG/dist/99.50'] = {'max': 7.1681064724676515, 'min': 5.9337052259880867} # lost: 2
limits['SW_cis/UG/dist/99.90'] = {'max': 7.3726289268682672, 'min': 5.2197275360409305} # lost: 0
limits['SW_cis/UG/dist/99.99'] = {'max': 7.3726289268682672, 'min': 5.2197275360409305} # lost: 0
limits['SW_cis/UG/min_dist/100.00'] = {'max': 2.6097843627953901, 'min': 1.4642027241451265} # lost: 0
limits['SW_cis/UG/min_dist/95.00'] = {'max': 2.5350880590406217, 'min': 1.536627310967341} # lost: 21
limits['SW_cis/UG/min_dist/99.00'] = {'max': 2.5991052099296699, 'min': 1.4755796309623621} # lost: 4
limits['SW_cis/UG/min_dist/99.50'] = {'max': 2.601305127375011, 'min': 1.4719358366328821} # lost: 2
limits['SW_cis/UG/min_dist/99.90'] = {'max': 2.6097843627953901, 'min': 1.4642027241451265} # lost: 0
limits['SW_cis/UG/min_dist/99.99'] = {'max': 2.6097843627953901, 'min': 1.4642027241451265} # lost: 0
limits['SW_cis/UG/n2_z/100.00'] = {'max': -0.69844061, 'min': -0.99952221} # lost: 0
limits['SW_cis/UG/n2_z/95.00'] = {'max': -0.81400812, 'min': -0.99952221} # lost: 21
limits['SW_cis/UG/n2_z/99.00'] = {'max': -0.70996636, 'min': -0.99952221} # lost: 4
limits['SW_cis/UG/n2_z/99.50'] = {'max': -0.70153838, 'min': -0.99952221} # lost: 2
limits['SW_cis/UG/n2_z/99.90'] = {'max': -0.69844061, 'min': -0.99952221} # lost: 0
limits['SW_cis/UG/n2_z/99.99'] = {'max': -0.69844061, 'min': -0.99952221} # lost: 0
limits['SW_cis/UG/nn_ang_norm/100.00'] = {'max': 46.030156109755325, 'min': 1.1582584704944168} # lost: 0
limits['SW_cis/UG/nn_ang_norm/95.00'] = {'max': 35.997673728517128, 'min': 1.1582584704944168} # lost: 21
limits['SW_cis/UG/nn_ang_norm/99.00'] = {'max': 44.812251418472016, 'min': 1.1582584704944168} # lost: 4
limits['SW_cis/UG/nn_ang_norm/99.50'] = {'max': 45.392025195979386, 'min': 1.1582584704944168} # lost: 2
limits['SW_cis/UG/nn_ang_norm/99.90'] = {'max': 46.030156109755325, 'min': 1.1582584704944168} # lost: 0
limits['SW_cis/UG/nn_ang_norm/99.99'] = {'max': 46.030156109755325, 'min': 1.1582584704944168} # lost: 0
limits['SW_cis/UG/rot_ang/100.00'] = {'max': 52.468102773972696, 'min': -50.028216710196247} # lost: 0
limits['SW_cis/UG/rot_ang/95.00'] = {'max': 43.50989623722662, 'min': -40.200566734626321} # lost: 21
limits['SW_cis/UG/rot_ang/99.00'] = {'max': 49.026208580493716, 'min': -42.906001863319133} # lost: 4
limits['SW_cis/UG/rot_ang/99.50'] = {'max': 49.74642103720295, 'min': -43.066572772589218} # lost: 2
limits['SW_cis/UG/rot_ang/99.90'] = {'max': 52.468102773972696, 'min': -50.028216710196247} # lost: 0
limits['SW_cis/UG/rot_ang/99.99'] = {'max': 52.468102773972696, 'min': -50.028216710196247} # lost: 0
limits['SW_cis/UU/dist/100.00'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['SW_cis/UU/dist/95.00'] = {'max': 6.8628254274157809, 'min': 6.1056794042907097} # lost: 3
limits['SW_cis/UU/dist/99.00'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['SW_cis/UU/dist/99.50'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['SW_cis/UU/dist/99.90'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['SW_cis/UU/dist/99.99'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['SW_cis/UU/min_dist/100.00'] = {'max': 2.4464478625046535, 'min': 1.558456930925892} # lost: 0
limits['SW_cis/UU/min_dist/95.00'] = {'max': 2.2852643161947097, 'min': 1.6964827371446423} # lost: 3
limits['SW_cis/UU/min_dist/99.00'] = {'max': 2.4464478625046535, 'min': 1.558456930925892} # lost: 0
limits['SW_cis/UU/min_dist/99.50'] = {'max': 2.4464478625046535, 'min': 1.558456930925892} # lost: 0
limits['SW_cis/UU/min_dist/99.90'] = {'max': 2.4464478625046535, 'min': 1.558456930925892} # lost: 0
limits['SW_cis/UU/min_dist/99.99'] = {'max': 2.4464478625046535, 'min': 1.558456930925892} # lost: 0
limits['SW_cis/UU/n2_z/100.00'] = {'max': -0.70797592, 'min': -0.9926008} # lost: 0
limits['SW_cis/UU/n2_z/95.00'] = {'max': -0.75122005, 'min': -0.9926008} # lost: 3
limits['SW_cis/UU/n2_z/99.00'] = {'max': -0.70797592, 'min': -0.9926008} # lost: 0
limits['SW_cis/UU/n2_z/99.50'] = {'max': -0.70797592, 'min': -0.9926008} # lost: 0
limits['SW_cis/UU/n2_z/99.90'] = {'max': -0.70797592, 'min': -0.9926008} # lost: 0
limits['SW_cis/UU/n2_z/99.99'] = {'max': -0.70797592, 'min': -0.9926008} # lost: 0
limits['SW_cis/UU/nn_ang_norm/100.00'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['SW_cis/UU/nn_ang_norm/95.00'] = {'max': 42.957581851246772, 'min': 11.758274930247325} # lost: 3
limits['SW_cis/UU/nn_ang_norm/99.00'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['SW_cis/UU/nn_ang_norm/99.50'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['SW_cis/UU/nn_ang_norm/99.90'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['SW_cis/UU/nn_ang_norm/99.99'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['SW_cis/UU/rot_ang/100.00'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['SW_cis/UU/rot_ang/95.00'] = {'max': 37.69802738578398, 'min': -52.962406468377985} # lost: 3
limits['SW_cis/UU/rot_ang/99.00'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['SW_cis/UU/rot_ang/99.50'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['SW_cis/UU/rot_ang/99.90'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['SW_cis/UU/rot_ang/99.99'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['SW_tran/AA/dist/100.00'] = {'max': 6.5410713628001007, 'min': 5.3468447587376993} # lost: 0
limits['SW_tran/AA/dist/95.00'] = {'max': 6.2190527867852126, 'min': 5.433459557681994} # lost: 13
limits['SW_tran/AA/dist/99.00'] = {'max': 6.538613288516764, 'min': 5.3483630186890911} # lost: 2
limits['SW_tran/AA/dist/99.50'] = {'max': 6.538613288516764, 'min': 5.3468447587376993} # lost: 1
limits['SW_tran/AA/dist/99.90'] = {'max': 6.5410713628001007, 'min': 5.3468447587376993} # lost: 0
limits['SW_tran/AA/dist/99.99'] = {'max': 6.5410713628001007, 'min': 5.3468447587376993} # lost: 0
limits['SW_tran/AA/min_dist/100.00'] = {'max': 2.5159182458958287, 'min': 1.343303271952061} # lost: 0
limits['SW_tran/AA/min_dist/95.00'] = {'max': 2.4544005612886837, 'min': 1.678731012669795} # lost: 13
limits['SW_tran/AA/min_dist/99.00'] = {'max': 2.5122212254215714, 'min': 1.5148236572852087} # lost: 2
limits['SW_tran/AA/min_dist/99.50'] = {'max': 2.5122212254215714, 'min': 1.343303271952061} # lost: 1
limits['SW_tran/AA/min_dist/99.90'] = {'max': 2.5159182458958287, 'min': 1.343303271952061} # lost: 0
limits['SW_tran/AA/min_dist/99.99'] = {'max': 2.5159182458958287, 'min': 1.343303271952061} # lost: 0
limits['SW_tran/AA/n2_z/100.00'] = {'max': 0.9978621, 'min': 0.51667911} # lost: 0
limits['SW_tran/AA/n2_z/95.00'] = {'max': 0.9978621, 'min': 0.83813941} # lost: 13
limits['SW_tran/AA/n2_z/99.00'] = {'max': 0.9978621, 'min': 0.74411142} # lost: 2
limits['SW_tran/AA/n2_z/99.50'] = {'max': 0.9978621, 'min': 0.71946543} # lost: 1
limits['SW_tran/AA/n2_z/99.90'] = {'max': 0.9978621, 'min': 0.51667911} # lost: 0
limits['SW_tran/AA/n2_z/99.99'] = {'max': 0.9978621, 'min': 0.51667911} # lost: 0
limits['SW_tran/AA/nn_ang_norm/100.00'] = {'max': 60.202769495542277, 'min': 3.5739075822665733} # lost: 0
limits['SW_tran/AA/nn_ang_norm/95.00'] = {'max': 33.290796222221957, 'min': 3.5739075822665733} # lost: 13
limits['SW_tran/AA/nn_ang_norm/99.00'] = {'max': 42.612354948604803, 'min': 3.5739075822665733} # lost: 2
limits['SW_tran/AA/nn_ang_norm/99.50'] = {'max': 44.072895279963646, 'min': 3.5739075822665733} # lost: 1
limits['SW_tran/AA/nn_ang_norm/99.90'] = {'max': 60.202769495542277, 'min': 3.5739075822665733} # lost: 0
limits['SW_tran/AA/nn_ang_norm/99.99'] = {'max': 60.202769495542277, 'min': 3.5739075822665733} # lost: 0
limits['SW_tran/AA/rot_ang/100.00'] = {'max': 99.156568395550721, 'min': 67.799581591364728} # lost: 0
limits['SW_tran/AA/rot_ang/95.00'] = {'max': 97.26013072589015, 'min': 77.254396525195773} # lost: 13
limits['SW_tran/AA/rot_ang/99.00'] = {'max': 98.880091309206264, 'min': 75.28772044284797} # lost: 2
limits['SW_tran/AA/rot_ang/99.50'] = {'max': 98.880091309206264, 'min': 67.799581591364728} # lost: 1
limits['SW_tran/AA/rot_ang/99.90'] = {'max': 99.156568395550721, 'min': 67.799581591364728} # lost: 0
limits['SW_tran/AA/rot_ang/99.99'] = {'max': 99.156568395550721, 'min': 67.799581591364728} # lost: 0
limits['SW_tran/AC/dist/100.00'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['SW_tran/AC/dist/95.00'] = {'max': 7.0550958390033713, 'min': 5.7463047426132867} # lost: 3
limits['SW_tran/AC/dist/99.00'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['SW_tran/AC/dist/99.50'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['SW_tran/AC/dist/99.90'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['SW_tran/AC/dist/99.99'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['SW_tran/AC/min_dist/100.00'] = {'max': 2.4956096174409792, 'min': 1.4039494764785729} # lost: 0
limits['SW_tran/AC/min_dist/95.00'] = {'max': 2.4468055852585735, 'min': 1.5171226577641339} # lost: 3
limits['SW_tran/AC/min_dist/99.00'] = {'max': 2.4956096174409792, 'min': 1.4039494764785729} # lost: 0
limits['SW_tran/AC/min_dist/99.50'] = {'max': 2.4956096174409792, 'min': 1.4039494764785729} # lost: 0
limits['SW_tran/AC/min_dist/99.90'] = {'max': 2.4956096174409792, 'min': 1.4039494764785729} # lost: 0
limits['SW_tran/AC/min_dist/99.99'] = {'max': 2.4956096174409792, 'min': 1.4039494764785729} # lost: 0
limits['SW_tran/AC/n2_z/100.00'] = {'max': 0.95969242, 'min': 0.67968547} # lost: 0
limits['SW_tran/AC/n2_z/95.00'] = {'max': 0.95969242, 'min': 0.73086858} # lost: 3
limits['SW_tran/AC/n2_z/99.00'] = {'max': 0.95969242, 'min': 0.67968547} # lost: 0
limits['SW_tran/AC/n2_z/99.50'] = {'max': 0.95969242, 'min': 0.67968547} # lost: 0
limits['SW_tran/AC/n2_z/99.90'] = {'max': 0.95969242, 'min': 0.67968547} # lost: 0
limits['SW_tran/AC/n2_z/99.99'] = {'max': 0.95969242, 'min': 0.67968547} # lost: 0
limits['SW_tran/AC/nn_ang_norm/100.00'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['SW_tran/AC/nn_ang_norm/95.00'] = {'max': 42.207877976145816, 'min': 16.331226484763317} # lost: 3
limits['SW_tran/AC/nn_ang_norm/99.00'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['SW_tran/AC/nn_ang_norm/99.50'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['SW_tran/AC/nn_ang_norm/99.90'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['SW_tran/AC/nn_ang_norm/99.99'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['SW_tran/AC/rot_ang/100.00'] = {'max': 99.614982394765448, 'min': 53.114485532916916} # lost: 0
limits['SW_tran/AC/rot_ang/95.00'] = {'max': 78.132435821683515, 'min': 53.121800277894735} # lost: 3
limits['SW_tran/AC/rot_ang/99.00'] = {'max': 99.614982394765448, 'min': 53.114485532916916} # lost: 0
limits['SW_tran/AC/rot_ang/99.50'] = {'max': 99.614982394765448, 'min': 53.114485532916916} # lost: 0
limits['SW_tran/AC/rot_ang/99.90'] = {'max': 99.614982394765448, 'min': 53.114485532916916} # lost: 0
limits['SW_tran/AC/rot_ang/99.99'] = {'max': 99.614982394765448, 'min': 53.114485532916916} # lost: 0
limits['SW_tran/AG/dist/100.00'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['SW_tran/AG/dist/95.00'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['SW_tran/AG/dist/99.00'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['SW_tran/AG/dist/99.50'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['SW_tran/AG/dist/99.90'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['SW_tran/AG/dist/99.99'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['SW_tran/AG/min_dist/100.00'] = {'max': 2.3387836409345057, 'min': 1.8965126518495496} # lost: 0
limits['SW_tran/AG/min_dist/95.00'] = {'max': 2.3387836409345057, 'min': 1.8965126518495496} # lost: 0
limits['SW_tran/AG/min_dist/99.00'] = {'max': 2.3387836409345057, 'min': 1.8965126518495496} # lost: 0
limits['SW_tran/AG/min_dist/99.50'] = {'max': 2.3387836409345057, 'min': 1.8965126518495496} # lost: 0
limits['SW_tran/AG/min_dist/99.90'] = {'max': 2.3387836409345057, 'min': 1.8965126518495496} # lost: 0
limits['SW_tran/AG/min_dist/99.99'] = {'max': 2.3387836409345057, 'min': 1.8965126518495496} # lost: 0
limits['SW_tran/AG/n2_z/100.00'] = {'max': 0.94365031, 'min': 0.60013944} # lost: 0
limits['SW_tran/AG/n2_z/95.00'] = {'max': 0.94365031, 'min': 0.60013944} # lost: 0
limits['SW_tran/AG/n2_z/99.00'] = {'max': 0.94365031, 'min': 0.60013944} # lost: 0
limits['SW_tran/AG/n2_z/99.50'] = {'max': 0.94365031, 'min': 0.60013944} # lost: 0
limits['SW_tran/AG/n2_z/99.90'] = {'max': 0.94365031, 'min': 0.60013944} # lost: 0
limits['SW_tran/AG/n2_z/99.99'] = {'max': 0.94365031, 'min': 0.60013944} # lost: 0
limits['SW_tran/AG/nn_ang_norm/100.00'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['SW_tran/AG/nn_ang_norm/95.00'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['SW_tran/AG/nn_ang_norm/99.00'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['SW_tran/AG/nn_ang_norm/99.50'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['SW_tran/AG/nn_ang_norm/99.90'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['SW_tran/AG/nn_ang_norm/99.99'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['SW_tran/AG/rot_ang/100.00'] = {'max': 123.76357490700414, 'min': 85.834526346423758} # lost: 0
limits['SW_tran/AG/rot_ang/95.00'] = {'max': 123.76357490700414, 'min': 85.834526346423758} # lost: 0
limits['SW_tran/AG/rot_ang/99.00'] = {'max': 123.76357490700414, 'min': 85.834526346423758} # lost: 0
limits['SW_tran/AG/rot_ang/99.50'] = {'max': 123.76357490700414, 'min': 85.834526346423758} # lost: 0
limits['SW_tran/AG/rot_ang/99.90'] = {'max': 123.76357490700414, 'min': 85.834526346423758} # lost: 0
limits['SW_tran/AG/rot_ang/99.99'] = {'max': 123.76357490700414, 'min': 85.834526346423758} # lost: 0
limits['SW_tran/AU/dist/100.00'] = {'max': 6.095428449029721, 'min': 5.1484045838449441} # lost: 0
limits['SW_tran/AU/dist/95.00'] = {'max': 5.9610839556889852, 'min': 5.3347074203533404} # lost: 26
limits['SW_tran/AU/dist/99.00'] = {'max': 6.0440259097048212, 'min': 5.1913455952812271} # lost: 5
limits['SW_tran/AU/dist/99.50'] = {'max': 6.0916702765156154, 'min': 5.1764616062167068} # lost: 2
limits['SW_tran/AU/dist/99.90'] = {'max': 6.095428449029721, 'min': 5.1484045838449441} # lost: 0
limits['SW_tran/AU/dist/99.99'] = {'max': 6.095428449029721, 'min': 5.1484045838449441} # lost: 0
limits['SW_tran/AU/min_dist/100.00'] = {'max': 2.6012206308094492, 'min': 1.5446675167365485} # lost: 0
limits['SW_tran/AU/min_dist/95.00'] = {'max': 2.3424335408004482, 'min': 1.7185146225721841} # lost: 26
limits['SW_tran/AU/min_dist/99.00'] = {'max': 2.4371208875569041, 'min': 1.6573928495694421} # lost: 5
limits['SW_tran/AU/min_dist/99.50'] = {'max': 2.5588951645829305, 'min': 1.5792991685566835} # lost: 2
limits['SW_tran/AU/min_dist/99.90'] = {'max': 2.6012206308094492, 'min': 1.5446675167365485} # lost: 0
limits['SW_tran/AU/min_dist/99.99'] = {'max': 2.6012206308094492, 'min': 1.5446675167365485} # lost: 0
limits['SW_tran/AU/n2_z/100.00'] = {'max': 0.99511802, 'min': 0.5450139} # lost: 0
limits['SW_tran/AU/n2_z/95.00'] = {'max': 0.99511802, 'min': 0.79524243} # lost: 26
limits['SW_tran/AU/n2_z/99.00'] = {'max': 0.99511802, 'min': 0.69419312} # lost: 5
limits['SW_tran/AU/n2_z/99.50'] = {'max': 0.99511802, 'min': 0.65380579} # lost: 2
limits['SW_tran/AU/n2_z/99.90'] = {'max': 0.99511802, 'min': 0.5450139} # lost: 0
limits['SW_tran/AU/n2_z/99.99'] = {'max': 0.99511802, 'min': 0.5450139} # lost: 0
limits['SW_tran/AU/nn_ang_norm/100.00'] = {'max': 57.11079749979087, 'min': 5.8840986869392644} # lost: 0
limits['SW_tran/AU/nn_ang_norm/95.00'] = {'max': 36.149117691750988, 'min': 5.8840986869392644} # lost: 26
limits['SW_tran/AU/nn_ang_norm/99.00'] = {'max': 45.863367899179963, 'min': 5.8840986869392644} # lost: 5
limits['SW_tran/AU/nn_ang_norm/99.50'] = {'max': 52.965125390592419, 'min': 5.8840986869392644} # lost: 2
limits['SW_tran/AU/nn_ang_norm/99.90'] = {'max': 57.11079749979087, 'min': 5.8840986869392644} # lost: 0
limits['SW_tran/AU/nn_ang_norm/99.99'] = {'max': 57.11079749979087, 'min': 5.8840986869392644} # lost: 0
limits['SW_tran/AU/rot_ang/100.00'] = {'max': 126.96051005193154, 'min': 81.110005832373147} # lost: 0
limits['SW_tran/AU/rot_ang/95.00'] = {'max': 115.52504490197815, 'min': 94.828201046801922} # lost: 26
limits['SW_tran/AU/rot_ang/99.00'] = {'max': 121.1323247815856, 'min': 91.535917826268744} # lost: 5
limits['SW_tran/AU/rot_ang/99.50'] = {'max': 125.28951099730887, 'min': 91.0933047528721} # lost: 2
limits['SW_tran/AU/rot_ang/99.90'] = {'max': 126.96051005193154, 'min': 81.110005832373147} # lost: 0
limits['SW_tran/AU/rot_ang/99.99'] = {'max': 126.96051005193154, 'min': 81.110005832373147} # lost: 0
limits['SW_tran/CA/dist/100.00'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['SW_tran/CA/dist/95.00'] = {'max': 7.8475875402067672, 'min': 7.3262570523448201} # lost: 3
limits['SW_tran/CA/dist/99.00'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['SW_tran/CA/dist/99.50'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['SW_tran/CA/dist/99.90'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['SW_tran/CA/dist/99.99'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['SW_tran/CA/min_dist/100.00'] = {'max': 2.1769320688423939, 'min': 1.4794416704168996} # lost: 0
limits['SW_tran/CA/min_dist/95.00'] = {'max': 2.1395571946366054, 'min': 1.7733484811881743} # lost: 3
limits['SW_tran/CA/min_dist/99.00'] = {'max': 2.1769320688423939, 'min': 1.4794416704168996} # lost: 0
limits['SW_tran/CA/min_dist/99.50'] = {'max': 2.1769320688423939, 'min': 1.4794416704168996} # lost: 0
limits['SW_tran/CA/min_dist/99.90'] = {'max': 2.1769320688423939, 'min': 1.4794416704168996} # lost: 0
limits['SW_tran/CA/min_dist/99.99'] = {'max': 2.1769320688423939, 'min': 1.4794416704168996} # lost: 0
limits['SW_tran/CA/n2_z/100.00'] = {'max': 0.99430573, 'min': 0.91808426} # lost: 0
limits['SW_tran/CA/n2_z/95.00'] = {'max': 0.99430573, 'min': 0.9441669} # lost: 3
limits['SW_tran/CA/n2_z/99.00'] = {'max': 0.99430573, 'min': 0.91808426} # lost: 0
limits['SW_tran/CA/n2_z/99.50'] = {'max': 0.99430573, 'min': 0.91808426} # lost: 0
limits['SW_tran/CA/n2_z/99.90'] = {'max': 0.99430573, 'min': 0.91808426} # lost: 0
limits['SW_tran/CA/n2_z/99.99'] = {'max': 0.99430573, 'min': 0.91808426} # lost: 0
limits['SW_tran/CA/nn_ang_norm/100.00'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['SW_tran/CA/nn_ang_norm/95.00'] = {'max': 19.791045148454934, 'min': 7.394410606779994} # lost: 3
limits['SW_tran/CA/nn_ang_norm/99.00'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['SW_tran/CA/nn_ang_norm/99.50'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['SW_tran/CA/nn_ang_norm/99.90'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['SW_tran/CA/nn_ang_norm/99.99'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['SW_tran/CA/rot_ang/100.00'] = {'max': 69.987099938378918, 'min': 57.420469621513185} # lost: 0
limits['SW_tran/CA/rot_ang/95.00'] = {'max': 66.669634434816771, 'min': 57.980468712477595} # lost: 3
limits['SW_tran/CA/rot_ang/99.00'] = {'max': 69.987099938378918, 'min': 57.420469621513185} # lost: 0
limits['SW_tran/CA/rot_ang/99.50'] = {'max': 69.987099938378918, 'min': 57.420469621513185} # lost: 0
limits['SW_tran/CA/rot_ang/99.90'] = {'max': 69.987099938378918, 'min': 57.420469621513185} # lost: 0
limits['SW_tran/CA/rot_ang/99.99'] = {'max': 69.987099938378918, 'min': 57.420469621513185} # lost: 0
limits['SW_tran/CC/dist/100.00'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['SW_tran/CC/dist/95.00'] = {'max': 7.6926000461578292, 'min': 6.9755181642732698} # lost: 2
limits['SW_tran/CC/dist/99.00'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['SW_tran/CC/dist/99.50'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['SW_tran/CC/dist/99.90'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['SW_tran/CC/dist/99.99'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['SW_tran/CC/min_dist/100.00'] = {'max': 2.4108031333004059, 'min': 1.6212458872942839} # lost: 0
limits['SW_tran/CC/min_dist/95.00'] = {'max': 2.3695914202914996, 'min': 1.7071386724300379} # lost: 2
limits['SW_tran/CC/min_dist/99.00'] = {'max': 2.4108031333004059, 'min': 1.6212458872942839} # lost: 0
limits['SW_tran/CC/min_dist/99.50'] = {'max': 2.4108031333004059, 'min': 1.6212458872942839} # lost: 0
limits['SW_tran/CC/min_dist/99.90'] = {'max': 2.4108031333004059, 'min': 1.6212458872942839} # lost: 0
limits['SW_tran/CC/min_dist/99.99'] = {'max': 2.4108031333004059, 'min': 1.6212458872942839} # lost: 0
limits['SW_tran/CC/n2_z/100.00'] = {'max': 0.94986689, 'min': 0.61337483} # lost: 0
limits['SW_tran/CC/n2_z/95.00'] = {'max': 0.94986689, 'min': 0.72716635} # lost: 2
limits['SW_tran/CC/n2_z/99.00'] = {'max': 0.94986689, 'min': 0.61337483} # lost: 0
limits['SW_tran/CC/n2_z/99.50'] = {'max': 0.94986689, 'min': 0.61337483} # lost: 0
limits['SW_tran/CC/n2_z/99.90'] = {'max': 0.94986689, 'min': 0.61337483} # lost: 0
limits['SW_tran/CC/n2_z/99.99'] = {'max': 0.94986689, 'min': 0.61337483} # lost: 0
limits['SW_tran/CC/nn_ang_norm/100.00'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['SW_tran/CC/nn_ang_norm/95.00'] = {'max': 43.338731906457319, 'min': 17.594777330269824} # lost: 2
limits['SW_tran/CC/nn_ang_norm/99.00'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['SW_tran/CC/nn_ang_norm/99.50'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['SW_tran/CC/nn_ang_norm/99.90'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['SW_tran/CC/nn_ang_norm/99.99'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['SW_tran/CC/rot_ang/100.00'] = {'max': 108.04514315328817, 'min': 80.352986828610298} # lost: 0
limits['SW_tran/CC/rot_ang/95.00'] = {'max': 107.25050041908301, 'min': 90.4923636892986} # lost: 2
limits['SW_tran/CC/rot_ang/99.00'] = {'max': 108.04514315328817, 'min': 80.352986828610298} # lost: 0
limits['SW_tran/CC/rot_ang/99.50'] = {'max': 108.04514315328817, 'min': 80.352986828610298} # lost: 0
limits['SW_tran/CC/rot_ang/99.90'] = {'max': 108.04514315328817, 'min': 80.352986828610298} # lost: 0
limits['SW_tran/CC/rot_ang/99.99'] = {'max': 108.04514315328817, 'min': 80.352986828610298} # lost: 0
limits['SW_tran/CG/dist/100.00'] = {'max': 7.5997016466555376, 'min': 6.0803410734014713} # lost: 0
limits['SW_tran/CG/dist/95.00'] = {'max': 7.434636840487471, 'min': 6.1507279619804063} # lost: 10
limits['SW_tran/CG/dist/99.00'] = {'max': 7.5315087813918309, 'min': 6.0869382678094741} # lost: 2
limits['SW_tran/CG/dist/99.50'] = {'max': 7.5315087813918309, 'min': 6.0803410734014713} # lost: 1
limits['SW_tran/CG/dist/99.90'] = {'max': 7.5997016466555376, 'min': 6.0803410734014713} # lost: 0
limits['SW_tran/CG/dist/99.99'] = {'max': 7.5997016466555376, 'min': 6.0803410734014713} # lost: 0
limits['SW_tran/CG/min_dist/100.00'] = {'max': 2.4803686610702171, 'min': 1.260557884831955} # lost: 0
limits['SW_tran/CG/min_dist/95.00'] = {'max': 2.3998642556378096, 'min': 1.5262712348655234} # lost: 10
limits['SW_tran/CG/min_dist/99.00'] = {'max': 2.4677202512779881, 'min': 1.3487020144363875} # lost: 2
limits['SW_tran/CG/min_dist/99.50'] = {'max': 2.4677202512779881, 'min': 1.260557884831955} # lost: 1
limits['SW_tran/CG/min_dist/99.90'] = {'max': 2.4803686610702171, 'min': 1.260557884831955} # lost: 0
limits['SW_tran/CG/min_dist/99.99'] = {'max': 2.4803686610702171, 'min': 1.260557884831955} # lost: 0
limits['SW_tran/CG/n2_z/100.00'] = {'max': 0.999448, 'min': 0.42990053} # lost: 0
limits['SW_tran/CG/n2_z/95.00'] = {'max': 0.999448, 'min': 0.52403522} # lost: 10
limits['SW_tran/CG/n2_z/99.00'] = {'max': 0.999448, 'min': 0.44901288} # lost: 2
limits['SW_tran/CG/n2_z/99.50'] = {'max': 0.999448, 'min': 0.44611725} # lost: 1
limits['SW_tran/CG/n2_z/99.90'] = {'max': 0.999448, 'min': 0.42990053} # lost: 0
limits['SW_tran/CG/n2_z/99.99'] = {'max': 0.999448, 'min': 0.42990053} # lost: 0
limits['SW_tran/CG/nn_ang_norm/100.00'] = {'max': 63.773141601139727, 'min': 1.8493853486851997} # lost: 0
limits['SW_tran/CG/nn_ang_norm/95.00'] = {'max': 58.516928544221393, 'min': 1.8493853486851997} # lost: 10
limits['SW_tran/CG/nn_ang_norm/99.00'] = {'max': 62.837542288631376, 'min': 1.8493853486851997} # lost: 2
limits['SW_tran/CG/nn_ang_norm/99.50'] = {'max': 63.32973255041167, 'min': 1.8493853486851997} # lost: 1
limits['SW_tran/CG/nn_ang_norm/99.90'] = {'max': 63.773141601139727, 'min': 1.8493853486851997} # lost: 0
limits['SW_tran/CG/nn_ang_norm/99.99'] = {'max': 63.773141601139727, 'min': 1.8493853486851997} # lost: 0
limits['SW_tran/CG/rot_ang/100.00'] = {'max': 140.27168782956275, 'min': 88.735967525115512} # lost: 0
limits['SW_tran/CG/rot_ang/95.00'] = {'max': 130.45217862691217, 'min': 92.830786403453615} # lost: 10
limits['SW_tran/CG/rot_ang/99.00'] = {'max': 139.97433397974385, 'min': 88.854063790056273} # lost: 2
limits['SW_tran/CG/rot_ang/99.50'] = {'max': 139.97433397974385, 'min': 88.735967525115512} # lost: 1
limits['SW_tran/CG/rot_ang/99.90'] = {'max': 140.27168782956275, 'min': 88.735967525115512} # lost: 0
limits['SW_tran/CG/rot_ang/99.99'] = {'max': 140.27168782956275, 'min': 88.735967525115512} # lost: 0
limits['SW_tran/CU/dist/100.00'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['SW_tran/CU/dist/95.00'] = {'max': 6.8431867255486836, 'min': 6.2424137095969101} # lost: 1
limits['SW_tran/CU/dist/99.00'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['SW_tran/CU/dist/99.50'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['SW_tran/CU/dist/99.90'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['SW_tran/CU/dist/99.99'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['SW_tran/CU/min_dist/100.00'] = {'max': 2.3078136078012124, 'min': 1.5489822001225126} # lost: 0
limits['SW_tran/CU/min_dist/95.00'] = {'max': 2.2636193507411249, 'min': 1.5489822001225126} # lost: 1
limits['SW_tran/CU/min_dist/99.00'] = {'max': 2.3078136078012124, 'min': 1.5489822001225126} # lost: 0
limits['SW_tran/CU/min_dist/99.50'] = {'max': 2.3078136078012124, 'min': 1.5489822001225126} # lost: 0
limits['SW_tran/CU/min_dist/99.90'] = {'max': 2.3078136078012124, 'min': 1.5489822001225126} # lost: 0
limits['SW_tran/CU/min_dist/99.99'] = {'max': 2.3078136078012124, 'min': 1.5489822001225126} # lost: 0
limits['SW_tran/CU/n2_z/100.00'] = {'max': 0.93464226, 'min': 0.69916916} # lost: 0
limits['SW_tran/CU/n2_z/95.00'] = {'max': 0.93464226, 'min': 0.72050083} # lost: 1
limits['SW_tran/CU/n2_z/99.00'] = {'max': 0.93464226, 'min': 0.69916916} # lost: 0
limits['SW_tran/CU/n2_z/99.50'] = {'max': 0.93464226, 'min': 0.69916916} # lost: 0
limits['SW_tran/CU/n2_z/99.90'] = {'max': 0.93464226, 'min': 0.69916916} # lost: 0
limits['SW_tran/CU/n2_z/99.99'] = {'max': 0.93464226, 'min': 0.69916916} # lost: 0
limits['SW_tran/CU/nn_ang_norm/100.00'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['SW_tran/CU/nn_ang_norm/95.00'] = {'max': 44.081825752303438, 'min': 20.823474345279259} # lost: 1
limits['SW_tran/CU/nn_ang_norm/99.00'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['SW_tran/CU/nn_ang_norm/99.50'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['SW_tran/CU/nn_ang_norm/99.90'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['SW_tran/CU/nn_ang_norm/99.99'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['SW_tran/CU/rot_ang/100.00'] = {'max': 144.29502876647342, 'min': 112.29427311448183} # lost: 0
limits['SW_tran/CU/rot_ang/95.00'] = {'max': 141.37377408842468, 'min': 112.29427311448183} # lost: 1
limits['SW_tran/CU/rot_ang/99.00'] = {'max': 144.29502876647342, 'min': 112.29427311448183} # lost: 0
limits['SW_tran/CU/rot_ang/99.50'] = {'max': 144.29502876647342, 'min': 112.29427311448183} # lost: 0
limits['SW_tran/CU/rot_ang/99.90'] = {'max': 144.29502876647342, 'min': 112.29427311448183} # lost: 0
limits['SW_tran/CU/rot_ang/99.99'] = {'max': 144.29502876647342, 'min': 112.29427311448183} # lost: 0
limits['SW_tran/GA/dist/100.00'] = {'max': 7.1362829073812364, 'min': 5.3788444386177243} # lost: 0
limits['SW_tran/GA/dist/95.00'] = {'max': 6.7177254257783368, 'min': 5.7656631712363913} # lost: 206
limits['SW_tran/GA/dist/99.00'] = {'max': 6.9279836467222546, 'min': 5.6034389778934823} # lost: 41
limits['SW_tran/GA/dist/99.50'] = {'max': 6.9673405081596433, 'min': 5.5660111413216722} # lost: 20
limits['SW_tran/GA/dist/99.90'] = {'max': 7.0816749823375282, 'min': 5.3959175643872541} # lost: 4
limits['SW_tran/GA/dist/99.99'] = {'max': 7.1362829073812364, 'min': 5.3788444386177243} # lost: 0
limits['SW_tran/GA/min_dist/100.00'] = {'max': 2.9957544710136679, 'min': 0.84097635309917229} # lost: 0
limits['SW_tran/GA/min_dist/95.00'] = {'max': 2.46432281769092, 'min': 1.5187842981328963} # lost: 206
limits['SW_tran/GA/min_dist/99.00'] = {'max': 2.6251967087157269, 'min': 1.2697308325033416} # lost: 41
limits['SW_tran/GA/min_dist/99.50'] = {'max': 2.7275349590098754, 'min': 1.1749453480928762} # lost: 20
limits['SW_tran/GA/min_dist/99.90'] = {'max': 2.823961061901477, 'min': 1.0345996794903249} # lost: 4
limits['SW_tran/GA/min_dist/99.99'] = {'max': 2.9957544710136679, 'min': 0.84097635309917229} # lost: 0
limits['SW_tran/GA/n2_z/100.00'] = {'max': 0.99994445, 'min': 0.41961116} # lost: 0
limits['SW_tran/GA/n2_z/95.00'] = {'max': 0.99994445, 'min': 0.67413974} # lost: 206
limits['SW_tran/GA/n2_z/99.00'] = {'max': 0.99994445, 'min': 0.46093026} # lost: 41
limits['SW_tran/GA/n2_z/99.50'] = {'max': 0.99994445, 'min': 0.44648221} # lost: 20
limits['SW_tran/GA/n2_z/99.90'] = {'max': 0.99994445, 'min': 0.42632148} # lost: 4
limits['SW_tran/GA/n2_z/99.99'] = {'max': 0.99994445, 'min': 0.41961116} # lost: 0
limits['SW_tran/GA/nn_ang_norm/100.00'] = {'max': 64.928625193598293, 'min': 0.57505299621297279} # lost: 0
limits['SW_tran/GA/nn_ang_norm/95.00'] = {'max': 47.394054273314836, 'min': 0.57505299621297279} # lost: 206
limits['SW_tran/GA/nn_ang_norm/99.00'] = {'max': 62.543120154268806, 'min': 0.57505299621297279} # lost: 41
limits['SW_tran/GA/nn_ang_norm/99.50'] = {'max': 63.415444594306159, 'min': 0.57505299621297279} # lost: 20
limits['SW_tran/GA/nn_ang_norm/99.90'] = {'max': 64.676591213224825, 'min': 0.57505299621297279} # lost: 4
limits['SW_tran/GA/nn_ang_norm/99.99'] = {'max': 64.928625193598293, 'min': 0.57505299621297279} # lost: 0
limits['SW_tran/GA/rot_ang/100.00'] = {'max': 130.47651405310384, 'min': 48.248226678611033} # lost: 0
limits['SW_tran/GA/rot_ang/95.00'] = {'max': 123.42263095424286, 'min': 57.965318161721058} # lost: 206
limits['SW_tran/GA/rot_ang/99.00'] = {'max': 127.4328038049659, 'min': 52.71324694318308} # lost: 41
limits['SW_tran/GA/rot_ang/99.50'] = {'max': 128.32161884236157, 'min': 52.010675342256292} # lost: 20
limits['SW_tran/GA/rot_ang/99.90'] = {'max': 129.22697548158624, 'min': 48.702830638245736} # lost: 4
limits['SW_tran/GA/rot_ang/99.99'] = {'max': 130.47651405310384, 'min': 48.248226678611033} # lost: 0
limits['SW_tran/GC/dist/100.00'] = {'max': 6.813238695997045, 'min': 5.1637584658639497} # lost: 0
limits['SW_tran/GC/dist/95.00'] = {'max': 6.5795516353800245, 'min': 5.7057067083366961} # lost: 25
limits['SW_tran/GC/dist/99.00'] = {'max': 6.7072988599762189, 'min': 5.3890355985493708} # lost: 5
limits['SW_tran/GC/dist/99.50'] = {'max': 6.7927714474302547, 'min': 5.2664778149807638} # lost: 2
limits['SW_tran/GC/dist/99.90'] = {'max': 6.813238695997045, 'min': 5.1637584658639497} # lost: 0
limits['SW_tran/GC/dist/99.99'] = {'max': 6.813238695997045, 'min': 5.1637584658639497} # lost: 0
limits['SW_tran/GC/min_dist/100.00'] = {'max': 2.5481014328558653, 'min': 1.1834485009574667} # lost: 0
limits['SW_tran/GC/min_dist/95.00'] = {'max': 2.385661755549521, 'min': 1.5224512000488166} # lost: 25
limits['SW_tran/GC/min_dist/99.00'] = {'max': 2.5023807264906637, 'min': 1.2240368577384224} # lost: 5
limits['SW_tran/GC/min_dist/99.50'] = {'max': 2.5301909724807148, 'min': 1.1911757637053821} # lost: 2
limits['SW_tran/GC/min_dist/99.90'] = {'max': 2.5481014328558653, 'min': 1.1834485009574667} # lost: 0
limits['SW_tran/GC/min_dist/99.99'] = {'max': 2.5481014328558653, 'min': 1.1834485009574667} # lost: 0
limits['SW_tran/GC/n2_z/100.00'] = {'max': 0.99965727, 'min': 0.48245904} # lost: 0
limits['SW_tran/GC/n2_z/95.00'] = {'max': 0.99965727, 'min': 0.67270535} # lost: 25
limits['SW_tran/GC/n2_z/99.00'] = {'max': 0.99965727, 'min': 0.5400548} # lost: 5
limits['SW_tran/GC/n2_z/99.50'] = {'max': 0.99965727, 'min': 0.50669402} # lost: 2
limits['SW_tran/GC/n2_z/99.90'] = {'max': 0.99965727, 'min': 0.48245904} # lost: 0
limits['SW_tran/GC/n2_z/99.99'] = {'max': 0.99965727, 'min': 0.48245904} # lost: 0
limits['SW_tran/GC/nn_ang_norm/100.00'] = {'max': 61.119619938778939, 'min': 1.3508914626312238} # lost: 0
limits['SW_tran/GC/nn_ang_norm/95.00'] = {'max': 47.150120897297001, 'min': 1.3508914626312238} # lost: 25
limits['SW_tran/GC/nn_ang_norm/99.00'] = {'max': 57.198934260840709, 'min': 1.3508914626312238} # lost: 5
limits['SW_tran/GC/nn_ang_norm/99.50'] = {'max': 59.648410851936532, 'min': 1.3508914626312238} # lost: 2
limits['SW_tran/GC/nn_ang_norm/99.90'] = {'max': 61.119619938778939, 'min': 1.3508914626312238} # lost: 0
limits['SW_tran/GC/nn_ang_norm/99.99'] = {'max': 61.119619938778939, 'min': 1.3508914626312238} # lost: 0
limits['SW_tran/GC/rot_ang/100.00'] = {'max': 116.904099930984, 'min': 61.000659196559937} # lost: 0
limits['SW_tran/GC/rot_ang/95.00'] = {'max': 100.43371602377844, 'min': 71.726257573250209} # lost: 25
limits['SW_tran/GC/rot_ang/99.00'] = {'max': 107.92412539349159, 'min': 66.031504176435448} # lost: 5
limits['SW_tran/GC/rot_ang/99.50'] = {'max': 114.91919024901379, 'min': 65.661763451205857} # lost: 2
limits['SW_tran/GC/rot_ang/99.90'] = {'max': 116.904099930984, 'min': 61.000659196559937} # lost: 0
limits['SW_tran/GC/rot_ang/99.99'] = {'max': 116.904099930984, 'min': 61.000659196559937} # lost: 0
limits['SW_tran/GG/dist/100.00'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['SW_tran/GG/dist/95.00'] = {'max': 7.4130729929790089, 'min': 6.1704593736455733} # lost: 5
limits['SW_tran/GG/dist/99.00'] = {'max': 7.4498901232218389, 'min': 6.1427157257067533} # lost: 1
limits['SW_tran/GG/dist/99.50'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['SW_tran/GG/dist/99.90'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['SW_tran/GG/dist/99.99'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['SW_tran/GG/min_dist/100.00'] = {'max': 2.4103631099839262, 'min': 1.0740020466109166} # lost: 0
limits['SW_tran/GG/min_dist/95.00'] = {'max': 2.2457001103521876, 'min': 1.0748220923559693} # lost: 5
limits['SW_tran/GG/min_dist/99.00'] = {'max': 2.2836584885704108, 'min': 1.0740020466109166} # lost: 1
limits['SW_tran/GG/min_dist/99.50'] = {'max': 2.4103631099839262, 'min': 1.0740020466109166} # lost: 0
limits['SW_tran/GG/min_dist/99.90'] = {'max': 2.4103631099839262, 'min': 1.0740020466109166} # lost: 0
limits['SW_tran/GG/min_dist/99.99'] = {'max': 2.4103631099839262, 'min': 1.0740020466109166} # lost: 0
limits['SW_tran/GG/n2_z/100.00'] = {'max': 0.99974638, 'min': 0.46798393} # lost: 0
limits['SW_tran/GG/n2_z/95.00'] = {'max': 0.99974638, 'min': 0.5834865} # lost: 5
limits['SW_tran/GG/n2_z/99.00'] = {'max': 0.99974638, 'min': 0.46814513} # lost: 1
limits['SW_tran/GG/n2_z/99.50'] = {'max': 0.99974638, 'min': 0.46798393} # lost: 0
limits['SW_tran/GG/n2_z/99.90'] = {'max': 0.99974638, 'min': 0.46798393} # lost: 0
limits['SW_tran/GG/n2_z/99.99'] = {'max': 0.99974638, 'min': 0.46798393} # lost: 0
limits['SW_tran/GG/nn_ang_norm/100.00'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['SW_tran/GG/nn_ang_norm/95.00'] = {'max': 54.609025565314845, 'min': 0.94626027730738449} # lost: 5
limits['SW_tran/GG/nn_ang_norm/99.00'] = {'max': 62.058887062871584, 'min': 0.94626027730738449} # lost: 1
limits['SW_tran/GG/nn_ang_norm/99.50'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['SW_tran/GG/nn_ang_norm/99.90'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['SW_tran/GG/nn_ang_norm/99.99'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['SW_tran/GG/rot_ang/100.00'] = {'max': 137.48687703110912, 'min': 74.526229834124308} # lost: 0
limits['SW_tran/GG/rot_ang/95.00'] = {'max': 137.47351385405108, 'min': 75.949212374667738} # lost: 5
limits['SW_tran/GG/rot_ang/99.00'] = {'max': 137.48010950408838, 'min': 74.526229834124308} # lost: 1
limits['SW_tran/GG/rot_ang/99.50'] = {'max': 137.48687703110912, 'min': 74.526229834124308} # lost: 0
limits['SW_tran/GG/rot_ang/99.90'] = {'max': 137.48687703110912, 'min': 74.526229834124308} # lost: 0
limits['SW_tran/GG/rot_ang/99.99'] = {'max': 137.48687703110912, 'min': 74.526229834124308} # lost: 0
limits['SW_tran/GU/dist/100.00'] = {'max': 7.5438836789803192, 'min': 5.3433248951412811} # lost: 0
limits['SW_tran/GU/dist/95.00'] = {'max': 7.2935428747480753, 'min': 5.4845148945435973} # lost: 10
limits['SW_tran/GU/dist/99.00'] = {'max': 7.3189378308807296, 'min': 5.3517511093982888} # lost: 2
limits['SW_tran/GU/dist/99.50'] = {'max': 7.3189378308807296, 'min': 5.3433248951412811} # lost: 1
limits['SW_tran/GU/dist/99.90'] = {'max': 7.5438836789803192, 'min': 5.3433248951412811} # lost: 0
limits['SW_tran/GU/dist/99.99'] = {'max': 7.5438836789803192, 'min': 5.3433248951412811} # lost: 0
limits['SW_tran/GU/min_dist/100.00'] = {'max': 2.3387543774284278, 'min': 1.1188694020455305} # lost: 0
limits['SW_tran/GU/min_dist/95.00'] = {'max': 2.2851609602063165, 'min': 1.5021993631693171} # lost: 10
limits['SW_tran/GU/min_dist/99.00'] = {'max': 2.3131838753835319, 'min': 1.2896685637203167} # lost: 2
limits['SW_tran/GU/min_dist/99.50'] = {'max': 2.3131838753835319, 'min': 1.1188694020455305} # lost: 1
limits['SW_tran/GU/min_dist/99.90'] = {'max': 2.3387543774284278, 'min': 1.1188694020455305} # lost: 0
limits['SW_tran/GU/min_dist/99.99'] = {'max': 2.3387543774284278, 'min': 1.1188694020455305} # lost: 0
limits['SW_tran/GU/n2_z/100.00'] = {'max': 0.99003154, 'min': 0.44066146} # lost: 0
limits['SW_tran/GU/n2_z/95.00'] = {'max': 0.99003154, 'min': 0.56671315} # lost: 10
limits['SW_tran/GU/n2_z/99.00'] = {'max': 0.99003154, 'min': 0.52600831} # lost: 2
limits['SW_tran/GU/n2_z/99.50'] = {'max': 0.99003154, 'min': 0.52404422} # lost: 1
limits['SW_tran/GU/n2_z/99.90'] = {'max': 0.99003154, 'min': 0.44066146} # lost: 0
limits['SW_tran/GU/n2_z/99.99'] = {'max': 0.99003154, 'min': 0.44066146} # lost: 0
limits['SW_tran/GU/nn_ang_norm/100.00'] = {'max': 59.323129922903846, 'min': 9.0213830114181874} # lost: 0
limits['SW_tran/GU/nn_ang_norm/95.00'] = {'max': 54.825364977085826, 'min': 9.0213830114181874} # lost: 10
limits['SW_tran/GU/nn_ang_norm/99.00'] = {'max': 58.289742792048429, 'min': 9.0213830114181874} # lost: 2
limits['SW_tran/GU/nn_ang_norm/99.50'] = {'max': 58.436182047853499, 'min': 9.0213830114181874} # lost: 1
limits['SW_tran/GU/nn_ang_norm/99.90'] = {'max': 59.323129922903846, 'min': 9.0213830114181874} # lost: 0
limits['SW_tran/GU/nn_ang_norm/99.99'] = {'max': 59.323129922903846, 'min': 9.0213830114181874} # lost: 0
limits['SW_tran/GU/rot_ang/100.00'] = {'max': 145.41069766276311, 'min': 63.489653067460743} # lost: 0
limits['SW_tran/GU/rot_ang/95.00'] = {'max': 140.27423910005857, 'min': 79.14259078676163} # lost: 10
limits['SW_tran/GU/rot_ang/99.00'] = {'max': 141.18710284766667, 'min': 66.953413655835988} # lost: 2
limits['SW_tran/GU/rot_ang/99.50'] = {'max': 141.18710284766667, 'min': 63.489653067460743} # lost: 1
limits['SW_tran/GU/rot_ang/99.90'] = {'max': 145.41069766276311, 'min': 63.489653067460743} # lost: 0
limits['SW_tran/GU/rot_ang/99.99'] = {'max': 145.41069766276311, 'min': 63.489653067460743} # lost: 0
limits['SW_tran/UA/dist/100.00'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['SW_tran/UA/dist/95.00'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['SW_tran/UA/dist/99.00'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['SW_tran/UA/dist/99.50'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['SW_tran/UA/dist/99.90'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['SW_tran/UA/dist/99.99'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['SW_tran/UA/min_dist/100.00'] = {'max': 2.3770019290165538, 'min': 1.5763754808520622} # lost: 0
limits['SW_tran/UA/min_dist/95.00'] = {'max': 2.3770019290165538, 'min': 1.5763754808520622} # lost: 0
limits['SW_tran/UA/min_dist/99.00'] = {'max': 2.3770019290165538, 'min': 1.5763754808520622} # lost: 0
limits['SW_tran/UA/min_dist/99.50'] = {'max': 2.3770019290165538, 'min': 1.5763754808520622} # lost: 0
limits['SW_tran/UA/min_dist/99.90'] = {'max': 2.3770019290165538, 'min': 1.5763754808520622} # lost: 0
limits['SW_tran/UA/min_dist/99.99'] = {'max': 2.3770019290165538, 'min': 1.5763754808520622} # lost: 0
limits['SW_tran/UA/n2_z/100.00'] = {'max': 0.93432873, 'min': 0.67908835} # lost: 0
limits['SW_tran/UA/n2_z/95.00'] = {'max': 0.93432873, 'min': 0.67908835} # lost: 0
limits['SW_tran/UA/n2_z/99.00'] = {'max': 0.93432873, 'min': 0.67908835} # lost: 0
limits['SW_tran/UA/n2_z/99.50'] = {'max': 0.93432873, 'min': 0.67908835} # lost: 0
limits['SW_tran/UA/n2_z/99.90'] = {'max': 0.93432873, 'min': 0.67908835} # lost: 0
limits['SW_tran/UA/n2_z/99.99'] = {'max': 0.93432873, 'min': 0.67908835} # lost: 0
limits['SW_tran/UA/nn_ang_norm/100.00'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['SW_tran/UA/nn_ang_norm/95.00'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['SW_tran/UA/nn_ang_norm/99.00'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['SW_tran/UA/nn_ang_norm/99.50'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['SW_tran/UA/nn_ang_norm/99.90'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['SW_tran/UA/nn_ang_norm/99.99'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['SW_tran/UA/rot_ang/100.00'] = {'max': 135.46440186119571, 'min': 52.919530319215674} # lost: 0
limits['SW_tran/UA/rot_ang/95.00'] = {'max': 135.46440186119571, 'min': 52.919530319215674} # lost: 0
limits['SW_tran/UA/rot_ang/99.00'] = {'max': 135.46440186119571, 'min': 52.919530319215674} # lost: 0
limits['SW_tran/UA/rot_ang/99.50'] = {'max': 135.46440186119571, 'min': 52.919530319215674} # lost: 0
limits['SW_tran/UA/rot_ang/99.90'] = {'max': 135.46440186119571, 'min': 52.919530319215674} # lost: 0
limits['SW_tran/UA/rot_ang/99.99'] = {'max': 135.46440186119571, 'min': 52.919530319215674} # lost: 0
limits['SW_tran/UC/dist/100.00'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['SW_tran/UC/dist/95.00'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['SW_tran/UC/dist/99.00'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['SW_tran/UC/dist/99.50'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['SW_tran/UC/dist/99.90'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['SW_tran/UC/dist/99.99'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['SW_tran/UC/min_dist/100.00'] = {'max': 1.6381053760602671, 'min': 1.6336457337863928} # lost: 0
limits['SW_tran/UC/min_dist/95.00'] = {'max': 1.6381053760602671, 'min': 1.6336457337863928} # lost: 0
limits['SW_tran/UC/min_dist/99.00'] = {'max': 1.6381053760602671, 'min': 1.6336457337863928} # lost: 0
limits['SW_tran/UC/min_dist/99.50'] = {'max': 1.6381053760602671, 'min': 1.6336457337863928} # lost: 0
limits['SW_tran/UC/min_dist/99.90'] = {'max': 1.6381053760602671, 'min': 1.6336457337863928} # lost: 0
limits['SW_tran/UC/min_dist/99.99'] = {'max': 1.6381053760602671, 'min': 1.6336457337863928} # lost: 0
limits['SW_tran/UC/n2_z/100.00'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['SW_tran/UC/n2_z/95.00'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['SW_tran/UC/n2_z/99.00'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['SW_tran/UC/n2_z/99.50'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['SW_tran/UC/n2_z/99.90'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['SW_tran/UC/n2_z/99.99'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['SW_tran/UC/nn_ang_norm/100.00'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['SW_tran/UC/nn_ang_norm/95.00'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['SW_tran/UC/nn_ang_norm/99.00'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['SW_tran/UC/nn_ang_norm/99.50'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['SW_tran/UC/nn_ang_norm/99.90'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['SW_tran/UC/nn_ang_norm/99.99'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['SW_tran/UC/rot_ang/100.00'] = {'max': 106.02856604691014, 'min': 106.0141918630145} # lost: 0
limits['SW_tran/UC/rot_ang/95.00'] = {'max': 106.02856604691014, 'min': 106.0141918630145} # lost: 0
limits['SW_tran/UC/rot_ang/99.00'] = {'max': 106.02856604691014, 'min': 106.0141918630145} # lost: 0
limits['SW_tran/UC/rot_ang/99.50'] = {'max': 106.02856604691014, 'min': 106.0141918630145} # lost: 0
limits['SW_tran/UC/rot_ang/99.90'] = {'max': 106.02856604691014, 'min': 106.0141918630145} # lost: 0
limits['SW_tran/UC/rot_ang/99.99'] = {'max': 106.02856604691014, 'min': 106.0141918630145} # lost: 0
limits['SW_tran/UG/dist/100.00'] = {'max': 7.9162433888552126, 'min': 5.8699416056232456} # lost: 0
limits['SW_tran/UG/dist/95.00'] = {'max': 7.3627870413827292, 'min': 6.1911469950632991} # lost: 50
limits['SW_tran/UG/dist/99.00'] = {'max': 7.6470481562781947, 'min': 5.9211297753757721} # lost: 10
limits['SW_tran/UG/dist/99.50'] = {'max': 7.6475923144539184, 'min': 5.8796351162705784} # lost: 5
limits['SW_tran/UG/dist/99.90'] = {'max': 7.6599429726959327, 'min': 5.8699416056232456} # lost: 1
limits['SW_tran/UG/dist/99.99'] = {'max': 7.9162433888552126, 'min': 5.8699416056232456} # lost: 0
limits['SW_tran/UG/min_dist/100.00'] = {'max': 2.5775897736194078, 'min': 1.0344258309437477} # lost: 0
limits['SW_tran/UG/min_dist/95.00'] = {'max': 2.4275195680571247, 'min': 1.5272957103599427} # lost: 50
limits['SW_tran/UG/min_dist/99.00'] = {'max': 2.5133163562221403, 'min': 1.3787957478870825} # lost: 10
limits['SW_tran/UG/min_dist/99.50'] = {'max': 2.5215339357852407, 'min': 1.2446415751723574} # lost: 5
limits['SW_tran/UG/min_dist/99.90'] = {'max': 2.5332441099727312, 'min': 1.0344258309437477} # lost: 1
limits['SW_tran/UG/min_dist/99.99'] = {'max': 2.5775897736194078, 'min': 1.0344258309437477} # lost: 0
limits['SW_tran/UG/n2_z/100.00'] = {'max': 0.99998772, 'min': 0.49336904} # lost: 0
limits['SW_tran/UG/n2_z/95.00'] = {'max': 0.99998772, 'min': 0.84273064} # lost: 50
limits['SW_tran/UG/n2_z/99.00'] = {'max': 0.99998772, 'min': 0.74869609} # lost: 10
limits['SW_tran/UG/n2_z/99.50'] = {'max': 0.99998772, 'min': 0.72708023} # lost: 5
limits['SW_tran/UG/n2_z/99.90'] = {'max': 0.99998772, 'min': 0.64553624} # lost: 1
limits['SW_tran/UG/n2_z/99.99'] = {'max': 0.99998772, 'min': 0.49336904} # lost: 0
limits['SW_tran/UG/nn_ang_norm/100.00'] = {'max': 62.826006099123227, 'min': 0.54643887918055645} # lost: 0
limits['SW_tran/UG/nn_ang_norm/95.00'] = {'max': 33.00820397550185, 'min': 0.54643887918055645} # lost: 50
limits['SW_tran/UG/nn_ang_norm/99.00'] = {'max': 42.64555308306565, 'min': 0.54643887918055645} # lost: 10
limits['SW_tran/UG/nn_ang_norm/99.50'] = {'max': 43.559237733622005, 'min': 0.54643887918055645} # lost: 5
limits['SW_tran/UG/nn_ang_norm/99.90'] = {'max': 47.137078651076862, 'min': 0.54643887918055645} # lost: 1
limits['SW_tran/UG/nn_ang_norm/99.99'] = {'max': 62.826006099123227, 'min': 0.54643887918055645} # lost: 0
limits['SW_tran/UG/rot_ang/100.00'] = {'max': 137.33895865074609, 'min': 79.870177889996043} # lost: 0
limits['SW_tran/UG/rot_ang/95.00'] = {'max': 122.41811204154529, 'min': 91.629762830787612} # lost: 50
limits['SW_tran/UG/rot_ang/99.00'] = {'max': 124.70864866318534, 'min': 87.103876374411698} # lost: 10
limits['SW_tran/UG/rot_ang/99.50'] = {'max': 124.95151024258516, 'min': 84.286782191493486} # lost: 5
limits['SW_tran/UG/rot_ang/99.90'] = {'max': 131.50915527644116, 'min': 79.870177889996043} # lost: 1
limits['SW_tran/UG/rot_ang/99.99'] = {'max': 137.33895865074609, 'min': 79.870177889996043} # lost: 0
limits['SW_tran/UU/dist/100.00'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['SW_tran/UU/dist/95.00'] = {'max': 6.8654424108094059, 'min': 6.4226963798501044} # lost: 1
limits['SW_tran/UU/dist/99.00'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['SW_tran/UU/dist/99.50'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['SW_tran/UU/dist/99.90'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['SW_tran/UU/dist/99.99'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['SW_tran/UU/min_dist/100.00'] = {'max': 2.2688245445047959, 'min': 1.731708427555924} # lost: 0
limits['SW_tran/UU/min_dist/95.00'] = {'max': 2.2630593434198003, 'min': 1.731708427555924} # lost: 1
limits['SW_tran/UU/min_dist/99.00'] = {'max': 2.2688245445047959, 'min': 1.731708427555924} # lost: 0
limits['SW_tran/UU/min_dist/99.50'] = {'max': 2.2688245445047959, 'min': 1.731708427555924} # lost: 0
limits['SW_tran/UU/min_dist/99.90'] = {'max': 2.2688245445047959, 'min': 1.731708427555924} # lost: 0
limits['SW_tran/UU/min_dist/99.99'] = {'max': 2.2688245445047959, 'min': 1.731708427555924} # lost: 0
limits['SW_tran/UU/n2_z/100.00'] = {'max': 0.98977399, 'min': 0.55735683} # lost: 0
limits['SW_tran/UU/n2_z/95.00'] = {'max': 0.98977399, 'min': 0.60424745} # lost: 1
limits['SW_tran/UU/n2_z/99.00'] = {'max': 0.98977399, 'min': 0.55735683} # lost: 0
limits['SW_tran/UU/n2_z/99.50'] = {'max': 0.98977399, 'min': 0.55735683} # lost: 0
limits['SW_tran/UU/n2_z/99.90'] = {'max': 0.98977399, 'min': 0.55735683} # lost: 0
limits['SW_tran/UU/n2_z/99.99'] = {'max': 0.98977399, 'min': 0.55735683} # lost: 0
limits['SW_tran/UU/nn_ang_norm/100.00'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['SW_tran/UU/nn_ang_norm/95.00'] = {'max': 53.748974975216008, 'min': 7.6395401196762283} # lost: 1
limits['SW_tran/UU/nn_ang_norm/99.00'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['SW_tran/UU/nn_ang_norm/99.50'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['SW_tran/UU/nn_ang_norm/99.90'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['SW_tran/UU/nn_ang_norm/99.99'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['SW_tran/UU/rot_ang/100.00'] = {'max': 147.39877602119171, 'min': 82.335253814604869} # lost: 0
limits['SW_tran/UU/rot_ang/95.00'] = {'max': 142.89649086118808, 'min': 82.335253814604869} # lost: 1
limits['SW_tran/UU/rot_ang/99.00'] = {'max': 147.39877602119171, 'min': 82.335253814604869} # lost: 0
limits['SW_tran/UU/rot_ang/99.50'] = {'max': 147.39877602119171, 'min': 82.335253814604869} # lost: 0
limits['SW_tran/UU/rot_ang/99.90'] = {'max': 147.39877602119171, 'min': 82.335253814604869} # lost: 0
limits['SW_tran/UU/rot_ang/99.99'] = {'max': 147.39877602119171, 'min': 82.335253814604869} # lost: 0
limits['WH_cis/AA/dist/100.00'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['WH_cis/AA/dist/95.00'] = {'max': 7.7579640403216139, 'min': 5.8754347620220493} # lost: 4
limits['WH_cis/AA/dist/99.00'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['WH_cis/AA/dist/99.50'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['WH_cis/AA/dist/99.90'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['WH_cis/AA/dist/99.99'] = {'max': 7.7973106823059135, 'min': 5.0932633062673238} # lost: 0
limits['WH_cis/AA/min_dist/100.00'] = {'max': 2.5200284840137468, 'min': 0.9768985674995877} # lost: 0
limits['WH_cis/AA/min_dist/95.00'] = {'max': 2.3301542933742345, 'min': 1.0319682300942317} # lost: 4
limits['WH_cis/AA/min_dist/99.00'] = {'max': 2.5200284840137468, 'min': 0.9768985674995877} # lost: 0
limits['WH_cis/AA/min_dist/99.50'] = {'max': 2.5200284840137468, 'min': 0.9768985674995877} # lost: 0
limits['WH_cis/AA/min_dist/99.90'] = {'max': 2.5200284840137468, 'min': 0.9768985674995877} # lost: 0
limits['WH_cis/AA/min_dist/99.99'] = {'max': 2.5200284840137468, 'min': 0.9768985674995877} # lost: 0
limits['WH_cis/AA/n2_z/100.00'] = {'max': 0.99825132, 'min': 0.62279791} # lost: 0
limits['WH_cis/AA/n2_z/95.00'] = {'max': 0.99825132, 'min': 0.64609915} # lost: 4
limits['WH_cis/AA/n2_z/99.00'] = {'max': 0.99825132, 'min': 0.62279791} # lost: 0
limits['WH_cis/AA/n2_z/99.50'] = {'max': 0.99825132, 'min': 0.62279791} # lost: 0
limits['WH_cis/AA/n2_z/99.90'] = {'max': 0.99825132, 'min': 0.62279791} # lost: 0
limits['WH_cis/AA/n2_z/99.99'] = {'max': 0.99825132, 'min': 0.62279791} # lost: 0
limits['WH_cis/AA/nn_ang_norm/100.00'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['WH_cis/AA/nn_ang_norm/95.00'] = {'max': 48.162593988913841, 'min': 2.3997987042716158} # lost: 4
limits['WH_cis/AA/nn_ang_norm/99.00'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['WH_cis/AA/nn_ang_norm/99.50'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['WH_cis/AA/nn_ang_norm/99.90'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['WH_cis/AA/nn_ang_norm/99.99'] = {'max': 50.025975462425457, 'min': 2.3997987042716158} # lost: 0
limits['WH_cis/AA/rot_ang/100.00'] = {'max': 129.74847846836261, 'min': 59.634707805547471} # lost: 0
limits['WH_cis/AA/rot_ang/95.00'] = {'max': 124.74301643836694, 'min': 63.723112053839166} # lost: 4
limits['WH_cis/AA/rot_ang/99.00'] = {'max': 129.74847846836261, 'min': 59.634707805547471} # lost: 0
limits['WH_cis/AA/rot_ang/99.50'] = {'max': 129.74847846836261, 'min': 59.634707805547471} # lost: 0
limits['WH_cis/AA/rot_ang/99.90'] = {'max': 129.74847846836261, 'min': 59.634707805547471} # lost: 0
limits['WH_cis/AA/rot_ang/99.99'] = {'max': 129.74847846836261, 'min': 59.634707805547471} # lost: 0
limits['WH_cis/AC/dist/100.00'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['WH_cis/AC/dist/95.00'] = {'max': 6.3165742434447338, 'min': 5.1483252869825344} # lost: 1
limits['WH_cis/AC/dist/99.00'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['WH_cis/AC/dist/99.50'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['WH_cis/AC/dist/99.90'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['WH_cis/AC/dist/99.99'] = {'max': 6.5062730515390852, 'min': 5.1483252869825344} # lost: 0
limits['WH_cis/AC/min_dist/100.00'] = {'max': 2.1257979952707116, 'min': 1.0337624216033943} # lost: 0
limits['WH_cis/AC/min_dist/95.00'] = {'max': 1.8910498762125025, 'min': 1.0337624216033943} # lost: 1
limits['WH_cis/AC/min_dist/99.00'] = {'max': 2.1257979952707116, 'min': 1.0337624216033943} # lost: 0
limits['WH_cis/AC/min_dist/99.50'] = {'max': 2.1257979952707116, 'min': 1.0337624216033943} # lost: 0
limits['WH_cis/AC/min_dist/99.90'] = {'max': 2.1257979952707116, 'min': 1.0337624216033943} # lost: 0
limits['WH_cis/AC/min_dist/99.99'] = {'max': 2.1257979952707116, 'min': 1.0337624216033943} # lost: 0
limits['WH_cis/AC/n2_z/100.00'] = {'max': 0.9995923, 'min': 0.70689785} # lost: 0
limits['WH_cis/AC/n2_z/95.00'] = {'max': 0.9995923, 'min': 0.97788155} # lost: 1
limits['WH_cis/AC/n2_z/99.00'] = {'max': 0.9995923, 'min': 0.70689785} # lost: 0
limits['WH_cis/AC/n2_z/99.50'] = {'max': 0.9995923, 'min': 0.70689785} # lost: 0
limits['WH_cis/AC/n2_z/99.90'] = {'max': 0.9995923, 'min': 0.70689785} # lost: 0
limits['WH_cis/AC/n2_z/99.99'] = {'max': 0.9995923, 'min': 0.70689785} # lost: 0
limits['WH_cis/AC/nn_ang_norm/100.00'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['WH_cis/AC/nn_ang_norm/95.00'] = {'max': 13.423793393780954, 'min': 1.5142656388748148} # lost: 1
limits['WH_cis/AC/nn_ang_norm/99.00'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['WH_cis/AC/nn_ang_norm/99.50'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['WH_cis/AC/nn_ang_norm/99.90'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['WH_cis/AC/nn_ang_norm/99.99'] = {'max': 44.752707423149602, 'min': 1.5142656388748148} # lost: 0
limits['WH_cis/AC/rot_ang/100.00'] = {'max': 99.65195478633099, 'min': 62.302969299487394} # lost: 0
limits['WH_cis/AC/rot_ang/95.00'] = {'max': 96.370077913842763, 'min': 62.302969299487394} # lost: 1
limits['WH_cis/AC/rot_ang/99.00'] = {'max': 99.65195478633099, 'min': 62.302969299487394} # lost: 0
limits['WH_cis/AC/rot_ang/99.50'] = {'max': 99.65195478633099, 'min': 62.302969299487394} # lost: 0
limits['WH_cis/AC/rot_ang/99.90'] = {'max': 99.65195478633099, 'min': 62.302969299487394} # lost: 0
limits['WH_cis/AC/rot_ang/99.99'] = {'max': 99.65195478633099, 'min': 62.302969299487394} # lost: 0
limits['WH_cis/AG/dist/100.00'] = {'max': 8.1134495997262963, 'min': 5.015281578181602} # lost: 0
limits['WH_cis/AG/dist/95.00'] = {'max': 8.0687093354999675, 'min': 6.0710787173748324} # lost: 13
limits['WH_cis/AG/dist/99.00'] = {'max': 8.1081760515085985, 'min': 5.3792820898830511} # lost: 2
limits['WH_cis/AG/dist/99.50'] = {'max': 8.1081760515085985, 'min': 5.015281578181602} # lost: 1
limits['WH_cis/AG/dist/99.90'] = {'max': 8.1134495997262963, 'min': 5.015281578181602} # lost: 0
limits['WH_cis/AG/dist/99.99'] = {'max': 8.1134495997262963, 'min': 5.015281578181602} # lost: 0
limits['WH_cis/AG/min_dist/100.00'] = {'max': 2.5427509920393496, 'min': 1.2694701282608212} # lost: 0
limits['WH_cis/AG/min_dist/95.00'] = {'max': 2.3376537179433883, 'min': 1.622379063100382} # lost: 13
limits['WH_cis/AG/min_dist/99.00'] = {'max': 2.4908201400163525, 'min': 1.4498943307293242} # lost: 2
limits['WH_cis/AG/min_dist/99.50'] = {'max': 2.4908201400163525, 'min': 1.2694701282608212} # lost: 1
limits['WH_cis/AG/min_dist/99.90'] = {'max': 2.5427509920393496, 'min': 1.2694701282608212} # lost: 0
limits['WH_cis/AG/min_dist/99.99'] = {'max': 2.5427509920393496, 'min': 1.2694701282608212} # lost: 0
limits['WH_cis/AG/n2_z/100.00'] = {'max': 0.9993695, 'min': 0.44881296} # lost: 0
limits['WH_cis/AG/n2_z/95.00'] = {'max': 0.9993695, 'min': 0.77039385} # lost: 13
limits['WH_cis/AG/n2_z/99.00'] = {'max': 0.9993695, 'min': 0.56164783} # lost: 2
limits['WH_cis/AG/n2_z/99.50'] = {'max': 0.9993695, 'min': 0.50919384} # lost: 1
limits['WH_cis/AG/n2_z/99.90'] = {'max': 0.9993695, 'min': 0.44881296} # lost: 0
limits['WH_cis/AG/n2_z/99.99'] = {'max': 0.9993695, 'min': 0.44881296} # lost: 0
limits['WH_cis/AG/nn_ang_norm/100.00'] = {'max': 61.654013939440738, 'min': 2.2375590864821877} # lost: 0
limits['WH_cis/AG/nn_ang_norm/95.00'] = {'max': 39.65553190596043, 'min': 2.2375590864821877} # lost: 13
limits['WH_cis/AG/nn_ang_norm/99.00'] = {'max': 55.726232777664656, 'min': 2.2375590864821877} # lost: 2
limits['WH_cis/AG/nn_ang_norm/99.50'] = {'max': 59.488058500792143, 'min': 2.2375590864821877} # lost: 1
limits['WH_cis/AG/nn_ang_norm/99.90'] = {'max': 61.654013939440738, 'min': 2.2375590864821877} # lost: 0
limits['WH_cis/AG/nn_ang_norm/99.99'] = {'max': 61.654013939440738, 'min': 2.2375590864821877} # lost: 0
limits['WH_cis/AG/rot_ang/100.00'] = {'max': 139.8259023099252, 'min': 57.614673219663338} # lost: 0
limits['WH_cis/AG/rot_ang/95.00'] = {'max': 109.16730815134819, 'min': 77.678131088932091} # lost: 13
limits['WH_cis/AG/rot_ang/99.00'] = {'max': 114.03324675803646, 'min': 67.225451389453752} # lost: 2
limits['WH_cis/AG/rot_ang/99.50'] = {'max': 114.03324675803646, 'min': 57.614673219663338} # lost: 1
limits['WH_cis/AG/rot_ang/99.90'] = {'max': 139.8259023099252, 'min': 57.614673219663338} # lost: 0
limits['WH_cis/AG/rot_ang/99.99'] = {'max': 139.8259023099252, 'min': 57.614673219663338} # lost: 0
limits['WH_cis/AU/dist/100.00'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['WH_cis/AU/dist/95.00'] = {'max': 6.7490226497756227, 'min': 4.8157469719130379} # lost: 1
limits['WH_cis/AU/dist/99.00'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['WH_cis/AU/dist/99.50'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['WH_cis/AU/dist/99.90'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['WH_cis/AU/dist/99.99'] = {'max': 6.7578829068607318, 'min': 4.8157469719130379} # lost: 0
limits['WH_cis/AU/min_dist/100.00'] = {'max': 2.3931160637846567, 'min': 1.2876641152377784} # lost: 0
limits['WH_cis/AU/min_dist/95.00'] = {'max': 2.3644423187288779, 'min': 1.2876641152377784} # lost: 1
limits['WH_cis/AU/min_dist/99.00'] = {'max': 2.3931160637846567, 'min': 1.2876641152377784} # lost: 0
limits['WH_cis/AU/min_dist/99.50'] = {'max': 2.3931160637846567, 'min': 1.2876641152377784} # lost: 0
limits['WH_cis/AU/min_dist/99.90'] = {'max': 2.3931160637846567, 'min': 1.2876641152377784} # lost: 0
limits['WH_cis/AU/min_dist/99.99'] = {'max': 2.3931160637846567, 'min': 1.2876641152377784} # lost: 0
limits['WH_cis/AU/n2_z/100.00'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['WH_cis/AU/n2_z/95.00'] = {'max': 0.99137288, 'min': 0.61221051} # lost: 1
limits['WH_cis/AU/n2_z/99.00'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['WH_cis/AU/n2_z/99.50'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['WH_cis/AU/n2_z/99.90'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['WH_cis/AU/n2_z/99.99'] = {'max': 0.99137288, 'min': 0.509565} # lost: 0
limits['WH_cis/AU/nn_ang_norm/100.00'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['WH_cis/AU/nn_ang_norm/95.00'] = {'max': 52.068123477083816, 'min': 8.8426019561194575} # lost: 1
limits['WH_cis/AU/nn_ang_norm/99.00'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['WH_cis/AU/nn_ang_norm/99.50'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['WH_cis/AU/nn_ang_norm/99.90'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['WH_cis/AU/nn_ang_norm/99.99'] = {'max': 59.4350903837787, 'min': 8.8426019561194575} # lost: 0
limits['WH_cis/AU/rot_ang/100.00'] = {'max': 143.33548232244019, 'min': 60.011467691130541} # lost: 0
limits['WH_cis/AU/rot_ang/95.00'] = {'max': 143.25408397375045, 'min': 60.011467691130541} # lost: 1
limits['WH_cis/AU/rot_ang/99.00'] = {'max': 143.33548232244019, 'min': 60.011467691130541} # lost: 0
limits['WH_cis/AU/rot_ang/99.50'] = {'max': 143.33548232244019, 'min': 60.011467691130541} # lost: 0
limits['WH_cis/AU/rot_ang/99.90'] = {'max': 143.33548232244019, 'min': 60.011467691130541} # lost: 0
limits['WH_cis/AU/rot_ang/99.99'] = {'max': 143.33548232244019, 'min': 60.011467691130541} # lost: 0
limits['WH_cis/CA/dist/100.00'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['WH_cis/CA/dist/95.00'] = {'max': 8.0006603962441716, 'min': 5.7913702957757174} # lost: 1
limits['WH_cis/CA/dist/99.00'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['WH_cis/CA/dist/99.50'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['WH_cis/CA/dist/99.90'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['WH_cis/CA/dist/99.99'] = {'max': 8.0245174759593318, 'min': 5.7913702957757174} # lost: 0
limits['WH_cis/CA/min_dist/100.00'] = {'max': 2.4600779896150073, 'min': 1.3053129985408705} # lost: 0
limits['WH_cis/CA/min_dist/95.00'] = {'max': 2.4512798890986942, 'min': 1.3053129985408705} # lost: 1
limits['WH_cis/CA/min_dist/99.00'] = {'max': 2.4600779896150073, 'min': 1.3053129985408705} # lost: 0
limits['WH_cis/CA/min_dist/99.50'] = {'max': 2.4600779896150073, 'min': 1.3053129985408705} # lost: 0
limits['WH_cis/CA/min_dist/99.90'] = {'max': 2.4600779896150073, 'min': 1.3053129985408705} # lost: 0
limits['WH_cis/CA/min_dist/99.99'] = {'max': 2.4600779896150073, 'min': 1.3053129985408705} # lost: 0
limits['WH_cis/CA/n2_z/100.00'] = {'max': 0.99321824, 'min': 0.62758619} # lost: 0
limits['WH_cis/CA/n2_z/95.00'] = {'max': 0.99321824, 'min': 0.76705492} # lost: 1
limits['WH_cis/CA/n2_z/99.00'] = {'max': 0.99321824, 'min': 0.62758619} # lost: 0
limits['WH_cis/CA/n2_z/99.50'] = {'max': 0.99321824, 'min': 0.62758619} # lost: 0
limits['WH_cis/CA/n2_z/99.90'] = {'max': 0.99321824, 'min': 0.62758619} # lost: 0
limits['WH_cis/CA/n2_z/99.99'] = {'max': 0.99321824, 'min': 0.62758619} # lost: 0
limits['WH_cis/CA/nn_ang_norm/100.00'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['WH_cis/CA/nn_ang_norm/95.00'] = {'max': 41.031596457664563, 'min': 6.1326121316824169} # lost: 1
limits['WH_cis/CA/nn_ang_norm/99.00'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['WH_cis/CA/nn_ang_norm/99.50'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['WH_cis/CA/nn_ang_norm/99.90'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['WH_cis/CA/nn_ang_norm/99.99'] = {'max': 55.680938378183718, 'min': 6.1326121316824169} # lost: 0
limits['WH_cis/CA/rot_ang/100.00'] = {'max': 96.94131367828777, 'min': 59.680556936211268} # lost: 0
limits['WH_cis/CA/rot_ang/95.00'] = {'max': 95.7390380845371, 'min': 59.680556936211268} # lost: 1
limits['WH_cis/CA/rot_ang/99.00'] = {'max': 96.94131367828777, 'min': 59.680556936211268} # lost: 0
limits['WH_cis/CA/rot_ang/99.50'] = {'max': 96.94131367828777, 'min': 59.680556936211268} # lost: 0
limits['WH_cis/CA/rot_ang/99.90'] = {'max': 96.94131367828777, 'min': 59.680556936211268} # lost: 0
limits['WH_cis/CA/rot_ang/99.99'] = {'max': 96.94131367828777, 'min': 59.680556936211268} # lost: 0
limits['WH_cis/CC/dist/100.00'] = {'max': 7.5238530109889368, 'min': 5.4808437869078119} # lost: 0
limits['WH_cis/CC/dist/95.00'] = {'max': 7.3677045762287383, 'min': 6.0275731480121273} # lost: 14
limits['WH_cis/CC/dist/99.00'] = {'max': 7.455351380237035, 'min': 5.6546137673570724} # lost: 2
limits['WH_cis/CC/dist/99.50'] = {'max': 7.455351380237035, 'min': 5.4808437869078119} # lost: 1
limits['WH_cis/CC/dist/99.90'] = {'max': 7.5238530109889368, 'min': 5.4808437869078119} # lost: 0
limits['WH_cis/CC/dist/99.99'] = {'max': 7.5238530109889368, 'min': 5.4808437869078119} # lost: 0
limits['WH_cis/CC/min_dist/100.00'] = {'max': 2.562238199709665, 'min': 0.71170101871898017} # lost: 0
limits['WH_cis/CC/min_dist/95.00'] = {'max': 2.3829333644218824, 'min': 1.5097436816741612} # lost: 14
limits['WH_cis/CC/min_dist/99.00'] = {'max': 2.4763242272834605, 'min': 0.9779408938261408} # lost: 2
limits['WH_cis/CC/min_dist/99.50'] = {'max': 2.4763242272834605, 'min': 0.71170101871898017} # lost: 1
limits['WH_cis/CC/min_dist/99.90'] = {'max': 2.562238199709665, 'min': 0.71170101871898017} # lost: 0
limits['WH_cis/CC/min_dist/99.99'] = {'max': 2.562238199709665, 'min': 0.71170101871898017} # lost: 0
limits['WH_cis/CC/n2_z/100.00'] = {'max': 0.9999699, 'min': 0.65428305} # lost: 0
limits['WH_cis/CC/n2_z/95.00'] = {'max': 0.9999699, 'min': 0.79952931} # lost: 14
limits['WH_cis/CC/n2_z/99.00'] = {'max': 0.9999699, 'min': 0.66771024} # lost: 2
limits['WH_cis/CC/n2_z/99.50'] = {'max': 0.9999699, 'min': 0.66705918} # lost: 1
limits['WH_cis/CC/n2_z/99.90'] = {'max': 0.9999699, 'min': 0.65428305} # lost: 0
limits['WH_cis/CC/n2_z/99.99'] = {'max': 0.9999699, 'min': 0.65428305} # lost: 0
limits['WH_cis/CC/nn_ang_norm/100.00'] = {'max': 50.466409965769977, 'min': 0.97437984595520966} # lost: 0
limits['WH_cis/CC/nn_ang_norm/95.00'] = {'max': 37.134553479538333, 'min': 0.97437984595520966} # lost: 14
limits['WH_cis/CC/nn_ang_norm/99.00'] = {'max': 47.090093779776346, 'min': 0.97437984595520966} # lost: 2
limits['WH_cis/CC/nn_ang_norm/99.50'] = {'max': 48.089429002524668, 'min': 0.97437984595520966} # lost: 1
limits['WH_cis/CC/nn_ang_norm/99.90'] = {'max': 50.466409965769977, 'min': 0.97437984595520966} # lost: 0
limits['WH_cis/CC/nn_ang_norm/99.99'] = {'max': 50.466409965769977, 'min': 0.97437984595520966} # lost: 0
limits['WH_cis/CC/rot_ang/100.00'] = {'max': 96.623827285026891, 'min': 36.545349040041017} # lost: 0
limits['WH_cis/CC/rot_ang/95.00'] = {'max': 93.368549072889607, 'min': 38.675852068639301} # lost: 14
limits['WH_cis/CC/rot_ang/99.00'] = {'max': 96.216449450600919, 'min': 37.303665112384756} # lost: 2
limits['WH_cis/CC/rot_ang/99.50'] = {'max': 96.216449450600919, 'min': 36.545349040041017} # lost: 1
limits['WH_cis/CC/rot_ang/99.90'] = {'max': 96.623827285026891, 'min': 36.545349040041017} # lost: 0
limits['WH_cis/CC/rot_ang/99.99'] = {'max': 96.623827285026891, 'min': 36.545349040041017} # lost: 0
limits['WH_cis/CG/dist/100.00'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['WH_cis/CG/dist/95.00'] = {'max': 7.1335077739679136, 'min': 6.1596284055793866} # lost: 7
limits['WH_cis/CG/dist/99.00'] = {'max': 7.5498630103597213, 'min': 5.8695884481687735} # lost: 1
limits['WH_cis/CG/dist/99.50'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['WH_cis/CG/dist/99.90'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['WH_cis/CG/dist/99.99'] = {'max': 7.6665794694009781, 'min': 5.8695884481687735} # lost: 0
limits['WH_cis/CG/min_dist/100.00'] = {'max': 2.8681755308709516, 'min': 1.2926277058518147} # lost: 0
limits['WH_cis/CG/min_dist/95.00'] = {'max': 2.7437618770791312, 'min': 1.4285891856030242} # lost: 7
limits['WH_cis/CG/min_dist/99.00'] = {'max': 2.8618187409283125, 'min': 1.2926277058518147} # lost: 1
limits['WH_cis/CG/min_dist/99.50'] = {'max': 2.8681755308709516, 'min': 1.2926277058518147} # lost: 0
limits['WH_cis/CG/min_dist/99.90'] = {'max': 2.8681755308709516, 'min': 1.2926277058518147} # lost: 0
limits['WH_cis/CG/min_dist/99.99'] = {'max': 2.8681755308709516, 'min': 1.2926277058518147} # lost: 0
limits['WH_cis/CG/n2_z/100.00'] = {'max': 0.99995488, 'min': 0.47034341} # lost: 0
limits['WH_cis/CG/n2_z/95.00'] = {'max': 0.99995488, 'min': 0.72257} # lost: 7
limits['WH_cis/CG/n2_z/99.00'] = {'max': 0.99995488, 'min': 0.48510772} # lost: 1
limits['WH_cis/CG/n2_z/99.50'] = {'max': 0.99995488, 'min': 0.47034341} # lost: 0
limits['WH_cis/CG/n2_z/99.90'] = {'max': 0.99995488, 'min': 0.47034341} # lost: 0
limits['WH_cis/CG/n2_z/99.99'] = {'max': 0.99995488, 'min': 0.47034341} # lost: 0
limits['WH_cis/CG/nn_ang_norm/100.00'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['WH_cis/CG/nn_ang_norm/95.00'] = {'max': 44.060949279105294, 'min': 0.91042718393079358} # lost: 7
limits['WH_cis/CG/nn_ang_norm/99.00'] = {'max': 60.724042702808482, 'min': 0.91042718393079358} # lost: 1
limits['WH_cis/CG/nn_ang_norm/99.50'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['WH_cis/CG/nn_ang_norm/99.90'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['WH_cis/CG/nn_ang_norm/99.99'] = {'max': 61.717104396804146, 'min': 0.91042718393079358} # lost: 0
limits['WH_cis/CG/rot_ang/100.00'] = {'max': 111.16236366858745, 'min': 57.551927343314603} # lost: 0
limits['WH_cis/CG/rot_ang/95.00'] = {'max': 103.84556457640804, 'min': 63.126023832301279} # lost: 7
limits['WH_cis/CG/rot_ang/99.00'] = {'max': 109.20052661653557, 'min': 57.551927343314603} # lost: 1
limits['WH_cis/CG/rot_ang/99.50'] = {'max': 111.16236366858745, 'min': 57.551927343314603} # lost: 0
limits['WH_cis/CG/rot_ang/99.90'] = {'max': 111.16236366858745, 'min': 57.551927343314603} # lost: 0
limits['WH_cis/CG/rot_ang/99.99'] = {'max': 111.16236366858745, 'min': 57.551927343314603} # lost: 0
limits['WH_cis/CU/dist/100.00'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['WH_cis/CU/dist/95.00'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['WH_cis/CU/dist/99.00'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['WH_cis/CU/dist/99.50'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['WH_cis/CU/dist/99.90'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['WH_cis/CU/dist/99.99'] = {'max': 6.3864028727807014, 'min': 6.3784172187270443} # lost: 0
limits['WH_cis/CU/min_dist/100.00'] = {'max': 1.7397541828766443, 'min': 1.7395902843837829} # lost: 0
limits['WH_cis/CU/min_dist/95.00'] = {'max': 1.7397541828766443, 'min': 1.7395902843837829} # lost: 0
limits['WH_cis/CU/min_dist/99.00'] = {'max': 1.7397541828766443, 'min': 1.7395902843837829} # lost: 0
limits['WH_cis/CU/min_dist/99.50'] = {'max': 1.7397541828766443, 'min': 1.7395902843837829} # lost: 0
limits['WH_cis/CU/min_dist/99.90'] = {'max': 1.7397541828766443, 'min': 1.7395902843837829} # lost: 0
limits['WH_cis/CU/min_dist/99.99'] = {'max': 1.7397541828766443, 'min': 1.7395902843837829} # lost: 0
limits['WH_cis/CU/n2_z/100.00'] = {'max': 0.98431253, 'min': 0.98261845} # lost: 0
limits['WH_cis/CU/n2_z/95.00'] = {'max': 0.98431253, 'min': 0.98261845} # lost: 0
limits['WH_cis/CU/n2_z/99.00'] = {'max': 0.98431253, 'min': 0.98261845} # lost: 0
limits['WH_cis/CU/n2_z/99.50'] = {'max': 0.98431253, 'min': 0.98261845} # lost: 0
limits['WH_cis/CU/n2_z/99.90'] = {'max': 0.98431253, 'min': 0.98261845} # lost: 0
limits['WH_cis/CU/n2_z/99.99'] = {'max': 0.98431253, 'min': 0.98261845} # lost: 0
limits['WH_cis/CU/nn_ang_norm/100.00'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['WH_cis/CU/nn_ang_norm/95.00'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['WH_cis/CU/nn_ang_norm/99.00'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['WH_cis/CU/nn_ang_norm/99.50'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['WH_cis/CU/nn_ang_norm/99.90'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['WH_cis/CU/nn_ang_norm/99.99'] = {'max': 10.713201232036482, 'min': 8.6455424608281266} # lost: 0
limits['WH_cis/CU/rot_ang/100.00'] = {'max': 87.315316578653167, 'min': 87.208992900754637} # lost: 0
limits['WH_cis/CU/rot_ang/95.00'] = {'max': 87.315316578653167, 'min': 87.208992900754637} # lost: 0
limits['WH_cis/CU/rot_ang/99.00'] = {'max': 87.315316578653167, 'min': 87.208992900754637} # lost: 0
limits['WH_cis/CU/rot_ang/99.50'] = {'max': 87.315316578653167, 'min': 87.208992900754637} # lost: 0
limits['WH_cis/CU/rot_ang/99.90'] = {'max': 87.315316578653167, 'min': 87.208992900754637} # lost: 0
limits['WH_cis/CU/rot_ang/99.99'] = {'max': 87.315316578653167, 'min': 87.208992900754637} # lost: 0
limits['WH_cis/GA/dist/100.00'] = {'max': 7.243654811975631, 'min': 5.6796308184762001} # lost: 0
limits['WH_cis/GA/dist/95.00'] = {'max': 7.0649086831645942, 'min': 6.1370272057233866} # lost: 20
limits['WH_cis/GA/dist/99.00'] = {'max': 7.2068663716805732, 'min': 5.7222206548877104} # lost: 4
limits['WH_cis/GA/dist/99.50'] = {'max': 7.2152999955372037, 'min': 5.7047071016434749} # lost: 2
limits['WH_cis/GA/dist/99.90'] = {'max': 7.243654811975631, 'min': 5.6796308184762001} # lost: 0
limits['WH_cis/GA/dist/99.99'] = {'max': 7.243654811975631, 'min': 5.6796308184762001} # lost: 0
limits['WH_cis/GA/min_dist/100.00'] = {'max': 2.6479283091541506, 'min': 0.74849690496935306} # lost: 0
limits['WH_cis/GA/min_dist/95.00'] = {'max': 2.2816020704982267, 'min': 1.4610813372551426} # lost: 20
limits['WH_cis/GA/min_dist/99.00'] = {'max': 2.5042433232819254, 'min': 1.1885851944664734} # lost: 4
limits['WH_cis/GA/min_dist/99.50'] = {'max': 2.5154891914875943, 'min': 1.0558457112801585} # lost: 2
limits['WH_cis/GA/min_dist/99.90'] = {'max': 2.6479283091541506, 'min': 0.74849690496935306} # lost: 0
limits['WH_cis/GA/min_dist/99.99'] = {'max': 2.6479283091541506, 'min': 0.74849690496935306} # lost: 0
limits['WH_cis/GA/n2_z/100.00'] = {'max': 0.99993861, 'min': 0.44711152} # lost: 0
limits['WH_cis/GA/n2_z/95.00'] = {'max': 0.99993861, 'min': 0.63641912} # lost: 20
limits['WH_cis/GA/n2_z/99.00'] = {'max': 0.99993861, 'min': 0.55423427} # lost: 4
limits['WH_cis/GA/n2_z/99.50'] = {'max': 0.99993861, 'min': 0.52422929} # lost: 2
limits['WH_cis/GA/n2_z/99.90'] = {'max': 0.99993861, 'min': 0.44711152} # lost: 0
limits['WH_cis/GA/n2_z/99.99'] = {'max': 0.99993861, 'min': 0.44711152} # lost: 0
limits['WH_cis/GA/nn_ang_norm/100.00'] = {'max': 63.266218621319716, 'min': 0.50085046140018896} # lost: 0
limits['WH_cis/GA/nn_ang_norm/95.00'] = {'max': 51.261877702171752, 'min': 0.50085046140018896} # lost: 20
limits['WH_cis/GA/nn_ang_norm/99.00'] = {'max': 56.350894558397343, 'min': 0.50085046140018896} # lost: 4
limits['WH_cis/GA/nn_ang_norm/99.50'] = {'max': 58.699629274330064, 'min': 0.50085046140018896} # lost: 2
limits['WH_cis/GA/nn_ang_norm/99.90'] = {'max': 63.266218621319716, 'min': 0.50085046140018896} # lost: 0
limits['WH_cis/GA/nn_ang_norm/99.99'] = {'max': 63.266218621319716, 'min': 0.50085046140018896} # lost: 0
limits['WH_cis/GA/rot_ang/100.00'] = {'max': 128.35815062221982, 'min': 53.342609806569286} # lost: 0
limits['WH_cis/GA/rot_ang/95.00'] = {'max': 119.17608058618262, 'min': 59.831795372990264} # lost: 20
limits['WH_cis/GA/rot_ang/99.00'] = {'max': 124.53827559551293, 'min': 53.739386840518179} # lost: 4
limits['WH_cis/GA/rot_ang/99.50'] = {'max': 124.54092928618499, 'min': 53.522326764083857} # lost: 2
limits['WH_cis/GA/rot_ang/99.90'] = {'max': 128.35815062221982, 'min': 53.342609806569286} # lost: 0
limits['WH_cis/GA/rot_ang/99.99'] = {'max': 128.35815062221982, 'min': 53.342609806569286} # lost: 0
limits['WH_cis/GC/dist/100.00'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['WH_cis/GC/dist/95.00'] = {'max': 5.551871893901577, 'min': 5.1034801209014216} # lost: 2
limits['WH_cis/GC/dist/99.00'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['WH_cis/GC/dist/99.50'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['WH_cis/GC/dist/99.90'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['WH_cis/GC/dist/99.99'] = {'max': 6.8121703141688368, 'min': 5.1034419640164588} # lost: 0
limits['WH_cis/GC/min_dist/100.00'] = {'max': 1.9903258430782986, 'min': 0.43771560460007841} # lost: 0
limits['WH_cis/GC/min_dist/95.00'] = {'max': 1.9879581961813979, 'min': 0.73049966490985285} # lost: 2
limits['WH_cis/GC/min_dist/99.00'] = {'max': 1.9903258430782986, 'min': 0.43771560460007841} # lost: 0
limits['WH_cis/GC/min_dist/99.50'] = {'max': 1.9903258430782986, 'min': 0.43771560460007841} # lost: 0
limits['WH_cis/GC/min_dist/99.90'] = {'max': 1.9903258430782986, 'min': 0.43771560460007841} # lost: 0
limits['WH_cis/GC/min_dist/99.99'] = {'max': 1.9903258430782986, 'min': 0.43771560460007841} # lost: 0
limits['WH_cis/GC/n2_z/100.00'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['WH_cis/GC/n2_z/95.00'] = {'max': 0.99842197, 'min': 0.60652137} # lost: 2
limits['WH_cis/GC/n2_z/99.00'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['WH_cis/GC/n2_z/99.50'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['WH_cis/GC/n2_z/99.90'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['WH_cis/GC/n2_z/99.99'] = {'max': 0.99842197, 'min': 0.60596514} # lost: 0
limits['WH_cis/GC/nn_ang_norm/100.00'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['WH_cis/GC/nn_ang_norm/95.00'] = {'max': 52.706933994682181, 'min': 3.2821118690832849} # lost: 2
limits['WH_cis/GC/nn_ang_norm/99.00'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['WH_cis/GC/nn_ang_norm/99.50'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['WH_cis/GC/nn_ang_norm/99.90'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['WH_cis/GC/nn_ang_norm/99.99'] = {'max': 52.769549753898275, 'min': 3.2821118690832849} # lost: 0
limits['WH_cis/GC/rot_ang/100.00'] = {'max': 149.69865952532442, 'min': 67.189473574306291} # lost: 0
limits['WH_cis/GC/rot_ang/95.00'] = {'max': 89.381756850733055, 'min': 70.163318634003062} # lost: 2
limits['WH_cis/GC/rot_ang/99.00'] = {'max': 149.69865952532442, 'min': 67.189473574306291} # lost: 0
limits['WH_cis/GC/rot_ang/99.50'] = {'max': 149.69865952532442, 'min': 67.189473574306291} # lost: 0
limits['WH_cis/GC/rot_ang/99.90'] = {'max': 149.69865952532442, 'min': 67.189473574306291} # lost: 0
limits['WH_cis/GC/rot_ang/99.99'] = {'max': 149.69865952532442, 'min': 67.189473574306291} # lost: 0
limits['WH_cis/GG/dist/100.00'] = {'max': 7.7887620907861619, 'min': 5.1958287289375411} # lost: 0
limits['WH_cis/GG/dist/95.00'] = {'max': 7.1521793541995633, 'min': 6.0931454015822872} # lost: 108
limits['WH_cis/GG/dist/99.00'] = {'max': 7.3377793372429814, 'min': 5.7580097678428022} # lost: 21
limits['WH_cis/GG/dist/99.50'] = {'max': 7.4402603918843369, 'min': 5.5568796168623686} # lost: 10
limits['WH_cis/GG/dist/99.90'] = {'max': 7.4610383035067356, 'min': 5.2427240427883914} # lost: 2
limits['WH_cis/GG/dist/99.99'] = {'max': 7.7887620907861619, 'min': 5.1958287289375411} # lost: 0
limits['WH_cis/GG/min_dist/100.00'] = {'max': 2.6176356284025868, 'min': 0.99979863627241516} # lost: 0
limits['WH_cis/GG/min_dist/95.00'] = {'max': 2.352238592063248, 'min': 1.5231593366483278} # lost: 108
limits['WH_cis/GG/min_dist/99.00'] = {'max': 2.5323039575118385, 'min': 1.3834979757464636} # lost: 21
limits['WH_cis/GG/min_dist/99.50'] = {'max': 2.5431207116199985, 'min': 1.3617206957421482} # lost: 10
limits['WH_cis/GG/min_dist/99.90'] = {'max': 2.595657340826202, 'min': 1.2192489048166681} # lost: 2
limits['WH_cis/GG/min_dist/99.99'] = {'max': 2.6176356284025868, 'min': 0.99979863627241516} # lost: 0
limits['WH_cis/GG/n2_z/100.00'] = {'max': 0.99995041, 'min': 0.43970233} # lost: 0
limits['WH_cis/GG/n2_z/95.00'] = {'max': 0.99995041, 'min': 0.80479646} # lost: 108
limits['WH_cis/GG/n2_z/99.00'] = {'max': 0.99995041, 'min': 0.59984958} # lost: 21
limits['WH_cis/GG/n2_z/99.50'] = {'max': 0.99995041, 'min': 0.57031822} # lost: 10
limits['WH_cis/GG/n2_z/99.90'] = {'max': 0.99995041, 'min': 0.50080639} # lost: 2
limits['WH_cis/GG/n2_z/99.99'] = {'max': 0.99995041, 'min': 0.43970233} # lost: 0
limits['WH_cis/GG/nn_ang_norm/100.00'] = {'max': 63.894015458881441, 'min': 0.520769800980032} # lost: 0
limits['WH_cis/GG/nn_ang_norm/95.00'] = {'max': 36.927100143877531, 'min': 0.520769800980032} # lost: 108
limits['WH_cis/GG/nn_ang_norm/99.00'] = {'max': 53.514979524440541, 'min': 0.520769800980032} # lost: 21
limits['WH_cis/GG/nn_ang_norm/99.50'] = {'max': 56.58993751896945, 'min': 0.520769800980032} # lost: 10
limits['WH_cis/GG/nn_ang_norm/99.90'] = {'max': 60.867968448998994, 'min': 0.520769800980032} # lost: 2
limits['WH_cis/GG/nn_ang_norm/99.99'] = {'max': 63.894015458881441, 'min': 0.520769800980032} # lost: 0
limits['WH_cis/GG/rot_ang/100.00'] = {'max': 129.15621388480747, 'min': 57.31136139992747} # lost: 0
limits['WH_cis/GG/rot_ang/95.00'] = {'max': 104.11671838822691, 'min': 72.971344570180321} # lost: 108
limits['WH_cis/GG/rot_ang/99.00'] = {'max': 114.1863926452139, 'min': 65.22907809010519} # lost: 21
limits['WH_cis/GG/rot_ang/99.50'] = {'max': 117.81829036732346, 'min': 61.530373020119264} # lost: 10
limits['WH_cis/GG/rot_ang/99.90'] = {'max': 126.3012053827219, 'min': 57.528843313496651} # lost: 2
limits['WH_cis/GG/rot_ang/99.99'] = {'max': 129.15621388480747, 'min': 57.31136139992747} # lost: 0
limits['WH_cis/GU/dist/100.00'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['WH_cis/GU/dist/95.00'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['WH_cis/GU/dist/99.00'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['WH_cis/GU/dist/99.50'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['WH_cis/GU/dist/99.90'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['WH_cis/GU/dist/99.99'] = {'max': 6.8537568550051553, 'min': 5.5315732665088113} # lost: 0
limits['WH_cis/GU/min_dist/100.00'] = {'max': 2.0506758008341315, 'min': 1.2747832169849695} # lost: 0
limits['WH_cis/GU/min_dist/95.00'] = {'max': 2.0506758008341315, 'min': 1.2747832169849695} # lost: 0
limits['WH_cis/GU/min_dist/99.00'] = {'max': 2.0506758008341315, 'min': 1.2747832169849695} # lost: 0
limits['WH_cis/GU/min_dist/99.50'] = {'max': 2.0506758008341315, 'min': 1.2747832169849695} # lost: 0
limits['WH_cis/GU/min_dist/99.90'] = {'max': 2.0506758008341315, 'min': 1.2747832169849695} # lost: 0
limits['WH_cis/GU/min_dist/99.99'] = {'max': 2.0506758008341315, 'min': 1.2747832169849695} # lost: 0
limits['WH_cis/GU/n2_z/100.00'] = {'max': 0.9995811, 'min': 0.75022292} # lost: 0
limits['WH_cis/GU/n2_z/95.00'] = {'max': 0.9995811, 'min': 0.75022292} # lost: 0
limits['WH_cis/GU/n2_z/99.00'] = {'max': 0.9995811, 'min': 0.75022292} # lost: 0
limits['WH_cis/GU/n2_z/99.50'] = {'max': 0.9995811, 'min': 0.75022292} # lost: 0
limits['WH_cis/GU/n2_z/99.90'] = {'max': 0.9995811, 'min': 0.75022292} # lost: 0
limits['WH_cis/GU/n2_z/99.99'] = {'max': 0.9995811, 'min': 0.75022292} # lost: 0
limits['WH_cis/GU/nn_ang_norm/100.00'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['WH_cis/GU/nn_ang_norm/95.00'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['WH_cis/GU/nn_ang_norm/99.00'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['WH_cis/GU/nn_ang_norm/99.50'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['WH_cis/GU/nn_ang_norm/99.90'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['WH_cis/GU/nn_ang_norm/99.99'] = {'max': 42.18852805022717, 'min': 1.7334778922437295} # lost: 0
limits['WH_cis/GU/rot_ang/100.00'] = {'max': 107.04188132377107, 'min': 83.621093739564358} # lost: 0
limits['WH_cis/GU/rot_ang/95.00'] = {'max': 107.04188132377107, 'min': 83.621093739564358} # lost: 0
limits['WH_cis/GU/rot_ang/99.00'] = {'max': 107.04188132377107, 'min': 83.621093739564358} # lost: 0
limits['WH_cis/GU/rot_ang/99.50'] = {'max': 107.04188132377107, 'min': 83.621093739564358} # lost: 0
limits['WH_cis/GU/rot_ang/99.90'] = {'max': 107.04188132377107, 'min': 83.621093739564358} # lost: 0
limits['WH_cis/GU/rot_ang/99.99'] = {'max': 107.04188132377107, 'min': 83.621093739564358} # lost: 0
limits['WH_cis/UA/dist/100.00'] = {'max': 7.3416553014266057, 'min': 5.8520830719013661} # lost: 0
limits['WH_cis/UA/dist/95.00'] = {'max': 6.9670667527262014, 'min': 6.2138931830288753} # lost: 157
limits['WH_cis/UA/dist/99.00'] = {'max': 7.09455520294377, 'min': 6.0823972980757519} # lost: 31
limits['WH_cis/UA/dist/99.50'] = {'max': 7.189661263976916, 'min': 5.9780660760840663} # lost: 15
limits['WH_cis/UA/dist/99.90'] = {'max': 7.2711891935090183, 'min': 5.9300246547603299} # lost: 3
limits['WH_cis/UA/dist/99.99'] = {'max': 7.3416553014266057, 'min': 5.8520830719013661} # lost: 0
limits['WH_cis/UA/min_dist/100.00'] = {'max': 2.6701956125727673, 'min': 1.1672426094521997} # lost: 0
limits['WH_cis/UA/min_dist/95.00'] = {'max': 2.3112286021155155, 'min': 1.5731471245159059} # lost: 157
limits['WH_cis/UA/min_dist/99.00'] = {'max': 2.4566232051574239, 'min': 1.4547829171509956} # lost: 31
limits['WH_cis/UA/min_dist/99.50'] = {'max': 2.4944166542647888, 'min': 1.424678723728388} # lost: 15
limits['WH_cis/UA/min_dist/99.90'] = {'max': 2.6325496686408227, 'min': 1.1724886039874036} # lost: 3
limits['WH_cis/UA/min_dist/99.99'] = {'max': 2.6701956125727673, 'min': 1.1672426094521997} # lost: 0
limits['WH_cis/UA/n2_z/100.00'] = {'max': 0.99992019, 'min': 0.47184226} # lost: 0
limits['WH_cis/UA/n2_z/95.00'] = {'max': 0.99992019, 'min': 0.76202506} # lost: 157
limits['WH_cis/UA/n2_z/99.00'] = {'max': 0.99992019, 'min': 0.61358017} # lost: 31
limits['WH_cis/UA/n2_z/99.50'] = {'max': 0.99992019, 'min': 0.55534112} # lost: 15
limits['WH_cis/UA/n2_z/99.90'] = {'max': 0.99992019, 'min': 0.49557757} # lost: 3
limits['WH_cis/UA/n2_z/99.99'] = {'max': 0.99992019, 'min': 0.47184226} # lost: 0
limits['WH_cis/UA/nn_ang_norm/100.00'] = {'max': 61.471087813089454, 'min': 0.7190050493039567} # lost: 0
limits['WH_cis/UA/nn_ang_norm/95.00'] = {'max': 40.252924156431838, 'min': 0.7190050493039567} # lost: 157
limits['WH_cis/UA/nn_ang_norm/99.00'] = {'max': 52.142275425808059, 'min': 0.7190050493039567} # lost: 31
limits['WH_cis/UA/nn_ang_norm/99.50'] = {'max': 56.048498178178782, 'min': 0.7190050493039567} # lost: 15
limits['WH_cis/UA/nn_ang_norm/99.90'] = {'max': 59.800280108131766, 'min': 0.7190050493039567} # lost: 3
limits['WH_cis/UA/nn_ang_norm/99.99'] = {'max': 61.471087813089454, 'min': 0.7190050493039567} # lost: 0
limits['WH_cis/UA/rot_ang/100.00'] = {'max': 120.91159264146299, 'min': 37.950410170640346} # lost: 0
limits['WH_cis/UA/rot_ang/95.00'] = {'max': 82.064526558256048, 'min': 55.07190000659476} # lost: 157
limits['WH_cis/UA/rot_ang/99.00'] = {'max': 96.143060150911282, 'min': 48.982946648308101} # lost: 31
limits['WH_cis/UA/rot_ang/99.50'] = {'max': 97.45439236897667, 'min': 44.714076937101822} # lost: 15
limits['WH_cis/UA/rot_ang/99.90'] = {'max': 104.28797947134304, 'min': 39.989304817079891} # lost: 3
limits['WH_cis/UA/rot_ang/99.99'] = {'max': 120.91159264146299, 'min': 37.950410170640346} # lost: 0
limits['WH_cis/UC/dist/100.00'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['WH_cis/UC/dist/95.00'] = {'max': 7.4867185417475346, 'min': 5.4208483773788938} # lost: 9
limits['WH_cis/UC/dist/99.00'] = {'max': 7.5139163090787884, 'min': 5.2284493555345488} # lost: 1
limits['WH_cis/UC/dist/99.50'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['WH_cis/UC/dist/99.90'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['WH_cis/UC/dist/99.99'] = {'max': 7.5616661433642021, 'min': 5.2284493555345488} # lost: 0
limits['WH_cis/UC/min_dist/100.00'] = {'max': 2.4562383418593332, 'min': 0.99437565488186219} # lost: 0
limits['WH_cis/UC/min_dist/95.00'] = {'max': 2.3295618728392546, 'min': 1.0145956367179148} # lost: 9
limits['WH_cis/UC/min_dist/99.00'] = {'max': 2.3538449935306489, 'min': 0.99437565488186219} # lost: 1
limits['WH_cis/UC/min_dist/99.50'] = {'max': 2.4562383418593332, 'min': 0.99437565488186219} # lost: 0
limits['WH_cis/UC/min_dist/99.90'] = {'max': 2.4562383418593332, 'min': 0.99437565488186219} # lost: 0
limits['WH_cis/UC/min_dist/99.99'] = {'max': 2.4562383418593332, 'min': 0.99437565488186219} # lost: 0
limits['WH_cis/UC/n2_z/100.00'] = {'max': 0.99981868, 'min': 0.48384616} # lost: 0
limits['WH_cis/UC/n2_z/95.00'] = {'max': 0.99981868, 'min': 0.79980844} # lost: 9
limits['WH_cis/UC/n2_z/99.00'] = {'max': 0.99981868, 'min': 0.61452687} # lost: 1
limits['WH_cis/UC/n2_z/99.50'] = {'max': 0.99981868, 'min': 0.48384616} # lost: 0
limits['WH_cis/UC/n2_z/99.90'] = {'max': 0.99981868, 'min': 0.48384616} # lost: 0
limits['WH_cis/UC/n2_z/99.99'] = {'max': 0.99981868, 'min': 0.48384616} # lost: 0
limits['WH_cis/UC/nn_ang_norm/100.00'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['WH_cis/UC/nn_ang_norm/95.00'] = {'max': 37.153083782756575, 'min': 1.7634741620877215} # lost: 9
limits['WH_cis/UC/nn_ang_norm/99.00'] = {'max': 51.637445898968657, 'min': 1.7634741620877215} # lost: 1
limits['WH_cis/UC/nn_ang_norm/99.50'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['WH_cis/UC/nn_ang_norm/99.90'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['WH_cis/UC/nn_ang_norm/99.99'] = {'max': 61.884177654091829, 'min': 1.7634741620877215} # lost: 0
limits['WH_cis/UC/rot_ang/100.00'] = {'max': 115.87546561904536, 'min': 41.896673133449575} # lost: 0
limits['WH_cis/UC/rot_ang/95.00'] = {'max': 108.00946062903296, 'min': 44.871741808425483} # lost: 9
limits['WH_cis/UC/rot_ang/99.00'] = {'max': 115.87546561904536, 'min': 41.896673133449575} # lost: 1
limits['WH_cis/UC/rot_ang/99.50'] = {'max': 115.87546561904536, 'min': 41.896673133449575} # lost: 0
limits['WH_cis/UC/rot_ang/99.90'] = {'max': 115.87546561904536, 'min': 41.896673133449575} # lost: 0
limits['WH_cis/UC/rot_ang/99.99'] = {'max': 115.87546561904536, 'min': 41.896673133449575} # lost: 0
limits['WH_cis/UG/dist/100.00'] = {'max': 7.3880871083648554, 'min': 6.0860194029130028} # lost: 0
limits['WH_cis/UG/dist/95.00'] = {'max': 7.2698583239979344, 'min': 6.5193565590018832} # lost: 20
limits['WH_cis/UG/dist/99.00'] = {'max': 7.365575790798979, 'min': 6.1918362044458535} # lost: 4
limits['WH_cis/UG/dist/99.50'] = {'max': 7.387135491006859, 'min': 6.1302055310972712} # lost: 2
limits['WH_cis/UG/dist/99.90'] = {'max': 7.3880871083648554, 'min': 6.0860194029130028} # lost: 0
limits['WH_cis/UG/dist/99.99'] = {'max': 7.3880871083648554, 'min': 6.0860194029130028} # lost: 0
limits['WH_cis/UG/min_dist/100.00'] = {'max': 2.5489946441652749, 'min': 1.3353934676443073} # lost: 0
limits['WH_cis/UG/min_dist/95.00'] = {'max': 2.3904673687157527, 'min': 1.6996048662717924} # lost: 20
limits['WH_cis/UG/min_dist/99.00'] = {'max': 2.4829015779073562, 'min': 1.4229636386477242} # lost: 4
limits['WH_cis/UG/min_dist/99.50'] = {'max': 2.5153360932476785, 'min': 1.3568744636650349} # lost: 2
limits['WH_cis/UG/min_dist/99.90'] = {'max': 2.5489946441652749, 'min': 1.3353934676443073} # lost: 0
limits['WH_cis/UG/min_dist/99.99'] = {'max': 2.5489946441652749, 'min': 1.3353934676443073} # lost: 0
limits['WH_cis/UG/n2_z/100.00'] = {'max': 0.99556708, 'min': 0.51331097} # lost: 0
limits['WH_cis/UG/n2_z/95.00'] = {'max': 0.99556708, 'min': 0.86243367} # lost: 20
limits['WH_cis/UG/n2_z/99.00'] = {'max': 0.99556708, 'min': 0.78934634} # lost: 4
limits['WH_cis/UG/n2_z/99.50'] = {'max': 0.99556708, 'min': 0.7724517} # lost: 2
limits['WH_cis/UG/n2_z/99.90'] = {'max': 0.99556708, 'min': 0.51331097} # lost: 0
limits['WH_cis/UG/n2_z/99.99'] = {'max': 0.99556708, 'min': 0.51331097} # lost: 0
limits['WH_cis/UG/nn_ang_norm/100.00'] = {'max': 59.246208332471163, 'min': 5.2920946019493487} # lost: 0
limits['WH_cis/UG/nn_ang_norm/95.00'] = {'max': 30.671039600023128, 'min': 5.2920946019493487} # lost: 20
limits['WH_cis/UG/nn_ang_norm/99.00'] = {'max': 39.357865431742105, 'min': 5.2920946019493487} # lost: 4
limits['WH_cis/UG/nn_ang_norm/99.50'] = {'max': 43.723688198268405, 'min': 5.2920946019493487} # lost: 2
limits['WH_cis/UG/nn_ang_norm/99.90'] = {'max': 59.246208332471163, 'min': 5.2920946019493487} # lost: 0
limits['WH_cis/UG/nn_ang_norm/99.99'] = {'max': 59.246208332471163, 'min': 5.2920946019493487} # lost: 0
limits['WH_cis/UG/rot_ang/100.00'] = {'max': 97.936969228849009, 'min': 39.312938515248788} # lost: 0
limits['WH_cis/UG/rot_ang/95.00'] = {'max': 65.719091843567242, 'min': 45.138764895922044} # lost: 20
limits['WH_cis/UG/rot_ang/99.00'] = {'max': 84.886576173555056, 'min': 42.848771684063273} # lost: 4
limits['WH_cis/UG/rot_ang/99.50'] = {'max': 87.641498018568186, 'min': 40.545855185382102} # lost: 2
limits['WH_cis/UG/rot_ang/99.90'] = {'max': 97.936969228849009, 'min': 39.312938515248788} # lost: 0
limits['WH_cis/UG/rot_ang/99.99'] = {'max': 97.936969228849009, 'min': 39.312938515248788} # lost: 0
limits['WH_cis/UU/dist/100.00'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['WH_cis/UU/dist/95.00'] = {'max': 6.6587006008187899, 'min': 5.7598582239808911} # lost: 8
limits['WH_cis/UU/dist/99.00'] = {'max': 6.6919297687506809, 'min': 5.6287038760508166} # lost: 1
limits['WH_cis/UU/dist/99.50'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['WH_cis/UU/dist/99.90'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['WH_cis/UU/dist/99.99'] = {'max': 6.7307821464924631, 'min': 5.6287038760508166} # lost: 0
limits['WH_cis/UU/min_dist/100.00'] = {'max': 2.4168461403853336, 'min': 1.2723889075660841} # lost: 0
limits['WH_cis/UU/min_dist/95.00'] = {'max': 2.3207862422917582, 'min': 1.3959897545675473} # lost: 8
limits['WH_cis/UU/min_dist/99.00'] = {'max': 2.3909961025437565, 'min': 1.2723889075660841} # lost: 1
limits['WH_cis/UU/min_dist/99.50'] = {'max': 2.4168461403853336, 'min': 1.2723889075660841} # lost: 0
limits['WH_cis/UU/min_dist/99.90'] = {'max': 2.4168461403853336, 'min': 1.2723889075660841} # lost: 0
limits['WH_cis/UU/min_dist/99.99'] = {'max': 2.4168461403853336, 'min': 1.2723889075660841} # lost: 0
limits['WH_cis/UU/n2_z/100.00'] = {'max': 0.99916577, 'min': 0.44642648} # lost: 0
limits['WH_cis/UU/n2_z/95.00'] = {'max': 0.99916577, 'min': 0.57559872} # lost: 8
limits['WH_cis/UU/n2_z/99.00'] = {'max': 0.99916577, 'min': 0.48885486} # lost: 1
limits['WH_cis/UU/n2_z/99.50'] = {'max': 0.99916577, 'min': 0.44642648} # lost: 0
limits['WH_cis/UU/n2_z/99.90'] = {'max': 0.99916577, 'min': 0.44642648} # lost: 0
limits['WH_cis/UU/n2_z/99.99'] = {'max': 0.99916577, 'min': 0.44642648} # lost: 0
limits['WH_cis/UU/nn_ang_norm/100.00'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['WH_cis/UU/nn_ang_norm/95.00'] = {'max': 54.002094955667509, 'min': 2.584977298945121} # lost: 8
limits['WH_cis/UU/nn_ang_norm/99.00'] = {'max': 61.246162853531764, 'min': 2.584977298945121} # lost: 1
limits['WH_cis/UU/nn_ang_norm/99.50'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['WH_cis/UU/nn_ang_norm/99.90'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['WH_cis/UU/nn_ang_norm/99.99'] = {'max': 63.585960266935523, 'min': 2.584977298945121} # lost: 0
limits['WH_cis/UU/rot_ang/100.00'] = {'max': 101.47436232864648, 'min': 60.219312118810663} # lost: 0
limits['WH_cis/UU/rot_ang/95.00'] = {'max': 91.334039379084743, 'min': 64.934231252034223} # lost: 8
limits['WH_cis/UU/rot_ang/99.00'] = {'max': 92.515222481491008, 'min': 60.219312118810663} # lost: 1
limits['WH_cis/UU/rot_ang/99.50'] = {'max': 101.47436232864648, 'min': 60.219312118810663} # lost: 0
limits['WH_cis/UU/rot_ang/99.90'] = {'max': 101.47436232864648, 'min': 60.219312118810663} # lost: 0
limits['WH_cis/UU/rot_ang/99.99'] = {'max': 101.47436232864648, 'min': 60.219312118810663} # lost: 0
limits['WH_tran/AA/dist/100.00'] = {'max': 7.8785453776359304, 'min': 5.1196107108970264} # lost: 0
limits['WH_tran/AA/dist/95.00'] = {'max': 6.9927163981090237, 'min': 6.1555064191276037} # lost: 141
limits['WH_tran/AA/dist/99.00'] = {'max': 7.1842942975069892, 'min': 6.0091582151294354} # lost: 28
limits['WH_tran/AA/dist/99.50'] = {'max': 7.3768559234975575, 'min': 5.8557940292528698} # lost: 14
limits['WH_tran/AA/dist/99.90'] = {'max': 7.6583550464692056, 'min': 5.2636752184535132} # lost: 2
limits['WH_tran/AA/dist/99.99'] = {'max': 7.8785453776359304, 'min': 5.1196107108970264} # lost: 0
limits['WH_tran/AA/min_dist/100.00'] = {'max': 2.8576359654595369, 'min': 1.35414561793577} # lost: 0
limits['WH_tran/AA/min_dist/95.00'] = {'max': 2.426761470119529, 'min': 1.6591368106385145} # lost: 141
limits['WH_tran/AA/min_dist/99.00'] = {'max': 2.5396199792554963, 'min': 1.4976951291681877} # lost: 28
limits['WH_tran/AA/min_dist/99.50'] = {'max': 2.5858786519236716, 'min': 1.4296607845818263} # lost: 14
limits['WH_tran/AA/min_dist/99.90'] = {'max': 2.7475366236870502, 'min': 1.3551544238462698} # lost: 2
limits['WH_tran/AA/min_dist/99.99'] = {'max': 2.8576359654595369, 'min': 1.35414561793577} # lost: 0
limits['WH_tran/AA/n2_z/100.00'] = {'max': -0.43410707, 'min': -0.99992174} # lost: 0
limits['WH_tran/AA/n2_z/95.00'] = {'max': -0.6661796, 'min': -0.99992174} # lost: 141
limits['WH_tran/AA/n2_z/99.00'] = {'max': -0.52931839, 'min': -0.99992174} # lost: 28
limits['WH_tran/AA/n2_z/99.50'] = {'max': -0.4916243, 'min': -0.99992174} # lost: 14
limits['WH_tran/AA/n2_z/99.90'] = {'max': -0.44182363, 'min': -0.99992174} # lost: 2
limits['WH_tran/AA/n2_z/99.99'] = {'max': -0.43410707, 'min': -0.99992174} # lost: 0
limits['WH_tran/AA/nn_ang_norm/100.00'] = {'max': 64.04650125333481, 'min': 0.73675383643458758} # lost: 0
limits['WH_tran/AA/nn_ang_norm/95.00'] = {'max': 48.528516364740938, 'min': 0.73675383643458758} # lost: 141
limits['WH_tran/AA/nn_ang_norm/99.00'] = {'max': 57.918223303567586, 'min': 0.73675383643458758} # lost: 28
limits['WH_tran/AA/nn_ang_norm/99.50'] = {'max': 60.252508754311151, 'min': 0.73675383643458758} # lost: 14
limits['WH_tran/AA/nn_ang_norm/99.90'] = {'max': 63.728528626714038, 'min': 0.73675383643458758} # lost: 2
limits['WH_tran/AA/nn_ang_norm/99.99'] = {'max': 64.04650125333481, 'min': 0.73675383643458758} # lost: 0
limits['WH_tran/AA/rot_ang/100.00'] = {'max': 224.25025771075249, 'min': 148.33540054968321} # lost: 0
limits['WH_tran/AA/rot_ang/95.00'] = {'max': 191.98684964601074, 'min': 157.19802149152321} # lost: 141
limits['WH_tran/AA/rot_ang/99.00'] = {'max': 204.65561609206435, 'min': 152.73777173836697} # lost: 28
limits['WH_tran/AA/rot_ang/99.50'] = {'max': 213.35817122780139, 'min': 151.99998085409828} # lost: 14
limits['WH_tran/AA/rot_ang/99.90'] = {'max': 220.92110174252932, 'min': 149.02699658908645} # lost: 2
limits['WH_tran/AA/rot_ang/99.99'] = {'max': 224.25025771075249, 'min': 148.33540054968321} # lost: 0
limits['WH_tran/AC/dist/100.00'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['WH_tran/AC/dist/95.00'] = {'max': 6.579387341090011, 'min': 5.0984077003669821} # lost: 3
limits['WH_tran/AC/dist/99.00'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['WH_tran/AC/dist/99.50'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['WH_tran/AC/dist/99.90'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['WH_tran/AC/dist/99.99'] = {'max': 6.7281188429932719, 'min': 4.9517510543446885} # lost: 0
limits['WH_tran/AC/min_dist/100.00'] = {'max': 2.3621235449508888, 'min': 0.89439110858362725} # lost: 0
limits['WH_tran/AC/min_dist/95.00'] = {'max': 2.2437811784236508, 'min': 0.8944935287828969} # lost: 3
limits['WH_tran/AC/min_dist/99.00'] = {'max': 2.3621235449508888, 'min': 0.89439110858362725} # lost: 0
limits['WH_tran/AC/min_dist/99.50'] = {'max': 2.3621235449508888, 'min': 0.89439110858362725} # lost: 0
limits['WH_tran/AC/min_dist/99.90'] = {'max': 2.3621235449508888, 'min': 0.89439110858362725} # lost: 0
limits['WH_tran/AC/min_dist/99.99'] = {'max': 2.3621235449508888, 'min': 0.89439110858362725} # lost: 0
limits['WH_tran/AC/n2_z/100.00'] = {'max': -0.49991196, 'min': -0.99384987} # lost: 0
limits['WH_tran/AC/n2_z/95.00'] = {'max': -0.60165513, 'min': -0.99384987} # lost: 3
limits['WH_tran/AC/n2_z/99.00'] = {'max': -0.49991196, 'min': -0.99384987} # lost: 0
limits['WH_tran/AC/n2_z/99.50'] = {'max': -0.49991196, 'min': -0.99384987} # lost: 0
limits['WH_tran/AC/n2_z/99.90'] = {'max': -0.49991196, 'min': -0.99384987} # lost: 0
limits['WH_tran/AC/n2_z/99.99'] = {'max': -0.49991196, 'min': -0.99384987} # lost: 0
limits['WH_tran/AC/nn_ang_norm/100.00'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['WH_tran/AC/nn_ang_norm/95.00'] = {'max': 53.592664502198517, 'min': 6.4181734899429159} # lost: 3
limits['WH_tran/AC/nn_ang_norm/99.00'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['WH_tran/AC/nn_ang_norm/99.50'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['WH_tran/AC/nn_ang_norm/99.90'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['WH_tran/AC/nn_ang_norm/99.99'] = {'max': 60.098706554580801, 'min': 6.4181734899429159} # lost: 0
limits['WH_tran/AC/rot_ang/100.00'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['WH_tran/AC/rot_ang/95.00'] = {'max': 176.46594243209574, 'min': 136.54476186111572} # lost: 3
limits['WH_tran/AC/rot_ang/99.00'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['WH_tran/AC/rot_ang/99.50'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['WH_tran/AC/rot_ang/99.90'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['WH_tran/AC/rot_ang/99.99'] = {'max': 181.9345722440417, 'min': 132.59156591475411} # lost: 0
limits['WH_tran/AG/dist/100.00'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['WH_tran/AG/dist/95.00'] = {'max': 7.2955916486265657, 'min': 5.8446720394980689} # lost: 3
limits['WH_tran/AG/dist/99.00'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['WH_tran/AG/dist/99.50'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['WH_tran/AG/dist/99.90'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['WH_tran/AG/dist/99.99'] = {'max': 7.9724594629141166, 'min': 5.6789426875217588} # lost: 0
limits['WH_tran/AG/min_dist/100.00'] = {'max': 2.4915936902318339, 'min': 1.6374141262391961} # lost: 0
limits['WH_tran/AG/min_dist/95.00'] = {'max': 2.2873914334373344, 'min': 1.7052093136726545} # lost: 3
limits['WH_tran/AG/min_dist/99.00'] = {'max': 2.4915936902318339, 'min': 1.6374141262391961} # lost: 0
limits['WH_tran/AG/min_dist/99.50'] = {'max': 2.4915936902318339, 'min': 1.6374141262391961} # lost: 0
limits['WH_tran/AG/min_dist/99.90'] = {'max': 2.4915936902318339, 'min': 1.6374141262391961} # lost: 0
limits['WH_tran/AG/min_dist/99.99'] = {'max': 2.4915936902318339, 'min': 1.6374141262391961} # lost: 0
limits['WH_tran/AG/n2_z/100.00'] = {'max': -0.82131696, 'min': -0.99975222} # lost: 0
limits['WH_tran/AG/n2_z/95.00'] = {'max': -0.85194635, 'min': -0.99975222} # lost: 3
limits['WH_tran/AG/n2_z/99.00'] = {'max': -0.82131696, 'min': -0.99975222} # lost: 0
limits['WH_tran/AG/n2_z/99.50'] = {'max': -0.82131696, 'min': -0.99975222} # lost: 0
limits['WH_tran/AG/n2_z/99.90'] = {'max': -0.82131696, 'min': -0.99975222} # lost: 0
limits['WH_tran/AG/n2_z/99.99'] = {'max': -0.82131696, 'min': -0.99975222} # lost: 0
limits['WH_tran/AG/nn_ang_norm/100.00'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['WH_tran/AG/nn_ang_norm/95.00'] = {'max': 30.925370345190572, 'min': 1.5816482367651759} # lost: 3
limits['WH_tran/AG/nn_ang_norm/99.00'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['WH_tran/AG/nn_ang_norm/99.50'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['WH_tran/AG/nn_ang_norm/99.90'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['WH_tran/AG/nn_ang_norm/99.99'] = {'max': 36.227304688412971, 'min': 1.5816482367651759} # lost: 0
limits['WH_tran/AG/rot_ang/100.00'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['WH_tran/AG/rot_ang/95.00'] = {'max': 211.38781113304748, 'min': 164.75073067472678} # lost: 3
limits['WH_tran/AG/rot_ang/99.00'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['WH_tran/AG/rot_ang/99.50'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['WH_tran/AG/rot_ang/99.90'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['WH_tran/AG/rot_ang/99.99'] = {'max': 235.69573750434222, 'min': 161.9758340743455} # lost: 0
limits['WH_tran/AU/dist/100.00'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['WH_tran/AU/dist/95.00'] = {'max': 7.4577840796651422, 'min': 5.2240893255266885} # lost: 1
limits['WH_tran/AU/dist/99.00'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['WH_tran/AU/dist/99.50'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['WH_tran/AU/dist/99.90'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['WH_tran/AU/dist/99.99'] = {'max': 7.5807763735859837, 'min': 5.2240893255266885} # lost: 0
limits['WH_tran/AU/min_dist/100.00'] = {'max': 2.2946637368377054, 'min': 1.2449661487511667} # lost: 0
limits['WH_tran/AU/min_dist/95.00'] = {'max': 2.0936317263643272, 'min': 1.2449661487511667} # lost: 1
limits['WH_tran/AU/min_dist/99.00'] = {'max': 2.2946637368377054, 'min': 1.2449661487511667} # lost: 0
limits['WH_tran/AU/min_dist/99.50'] = {'max': 2.2946637368377054, 'min': 1.2449661487511667} # lost: 0
limits['WH_tran/AU/min_dist/99.90'] = {'max': 2.2946637368377054, 'min': 1.2449661487511667} # lost: 0
limits['WH_tran/AU/min_dist/99.99'] = {'max': 2.2946637368377054, 'min': 1.2449661487511667} # lost: 0
limits['WH_tran/AU/n2_z/100.00'] = {'max': -0.4405925, 'min': -0.99481302} # lost: 0
limits['WH_tran/AU/n2_z/95.00'] = {'max': -0.45999023, 'min': -0.99481302} # lost: 1
limits['WH_tran/AU/n2_z/99.00'] = {'max': -0.4405925, 'min': -0.99481302} # lost: 0
limits['WH_tran/AU/n2_z/99.50'] = {'max': -0.4405925, 'min': -0.99481302} # lost: 0
limits['WH_tran/AU/n2_z/99.90'] = {'max': -0.4405925, 'min': -0.99481302} # lost: 0
limits['WH_tran/AU/n2_z/99.99'] = {'max': -0.4405925, 'min': -0.99481302} # lost: 0
limits['WH_tran/AU/nn_ang_norm/100.00'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['WH_tran/AU/nn_ang_norm/95.00'] = {'max': 63.612114882500336, 'min': 5.2441186131310644} # lost: 1
limits['WH_tran/AU/nn_ang_norm/99.00'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['WH_tran/AU/nn_ang_norm/99.50'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['WH_tran/AU/nn_ang_norm/99.90'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['WH_tran/AU/nn_ang_norm/99.99'] = {'max': 63.741505986137057, 'min': 5.2441186131310644} # lost: 0
limits['WH_tran/AU/rot_ang/100.00'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['WH_tran/AU/rot_ang/95.00'] = {'max': 195.18901414888046, 'min': 151.66727253980827} # lost: 1
limits['WH_tran/AU/rot_ang/99.00'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['WH_tran/AU/rot_ang/99.50'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['WH_tran/AU/rot_ang/99.90'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['WH_tran/AU/rot_ang/99.99'] = {'max': 196.89334980075256, 'min': 151.66727253980827} # lost: 0
limits['WH_tran/CA/dist/100.00'] = {'max': 7.8111440462867519, 'min': 5.8480414000075731} # lost: 0
limits['WH_tran/CA/dist/95.00'] = {'max': 7.0342974770898659, 'min': 6.1383287613702162} # lost: 177
limits['WH_tran/CA/dist/99.00'] = {'max': 7.4304944767110577, 'min': 5.9980521340405453} # lost: 35
limits['WH_tran/CA/dist/99.50'] = {'max': 7.5488389970410656, 'min': 5.9695790824428796} # lost: 17
limits['WH_tran/CA/dist/99.90'] = {'max': 7.7693849524145682, 'min': 5.8846615569512313} # lost: 3
limits['WH_tran/CA/dist/99.99'] = {'max': 7.8111440462867519, 'min': 5.8480414000075731} # lost: 0
limits['WH_tran/CA/min_dist/100.00'] = {'max': 2.8512429719241719, 'min': 1.0362793109347526} # lost: 0
limits['WH_tran/CA/min_dist/95.00'] = {'max': 2.4006928647021128, 'min': 1.6353580138589303} # lost: 177
limits['WH_tran/CA/min_dist/99.00'] = {'max': 2.5437316840531849, 'min': 1.3964640111383941} # lost: 35
limits['WH_tran/CA/min_dist/99.50'] = {'max': 2.5855008421242989, 'min': 1.2747643063679139} # lost: 17
limits['WH_tran/CA/min_dist/99.90'] = {'max': 2.8094923439270039, 'min': 1.0532377416676406} # lost: 3
limits['WH_tran/CA/min_dist/99.99'] = {'max': 2.8512429719241719, 'min': 1.0362793109347526} # lost: 0
limits['WH_tran/CA/n2_z/100.00'] = {'max': -0.42282042, 'min': -0.99998987} # lost: 0
limits['WH_tran/CA/n2_z/95.00'] = {'max': -0.66503888, 'min': -0.99998987} # lost: 177
limits['WH_tran/CA/n2_z/99.00'] = {'max': -0.46866375, 'min': -0.99998987} # lost: 35
limits['WH_tran/CA/n2_z/99.50'] = {'max': -0.45061648, 'min': -0.99998987} # lost: 17
limits['WH_tran/CA/n2_z/99.90'] = {'max': -0.42938533, 'min': -0.99998987} # lost: 3
limits['WH_tran/CA/n2_z/99.99'] = {'max': -0.42282042, 'min': -0.99998987} # lost: 0
limits['WH_tran/CA/nn_ang_norm/100.00'] = {'max': 64.883786822929991, 'min': 0.17583138103648821} # lost: 0
limits['WH_tran/CA/nn_ang_norm/95.00'] = {'max': 48.182294075713003, 'min': 0.17583138103648821} # lost: 177
limits['WH_tran/CA/nn_ang_norm/99.00'] = {'max': 61.930372044681462, 'min': 0.17583138103648821} # lost: 35
limits['WH_tran/CA/nn_ang_norm/99.50'] = {'max': 63.275045046960216, 'min': 0.17583138103648821} # lost: 17
limits['WH_tran/CA/nn_ang_norm/99.90'] = {'max': 64.537810420712162, 'min': 0.17583138103648821} # lost: 3
limits['WH_tran/CA/nn_ang_norm/99.99'] = {'max': 64.883786822929991, 'min': 0.17583138103648821} # lost: 0
limits['WH_tran/CA/rot_ang/100.00'] = {'max': 214.85802162722212, 'min': 126.820835555144} # lost: 0
limits['WH_tran/CA/rot_ang/95.00'] = {'max': 178.5696440496655, 'min': 142.55628506686028} # lost: 177
limits['WH_tran/CA/rot_ang/99.00'] = {'max': 201.68632079076508, 'min': 137.24251398378527} # lost: 35
limits['WH_tran/CA/rot_ang/99.50'] = {'max': 208.24733734506438, 'min': 134.86217378021976} # lost: 17
limits['WH_tran/CA/rot_ang/99.90'] = {'max': 211.79209136965412, 'min': 129.07881757258951} # lost: 3
limits['WH_tran/CA/rot_ang/99.99'] = {'max': 214.85802162722212, 'min': 126.820835555144} # lost: 0
limits['WH_tran/CC/dist/100.00'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['WH_tran/CC/dist/95.00'] = {'max': 6.6121571596957898, 'min': 5.603628439139726} # lost: 6
limits['WH_tran/CC/dist/99.00'] = {'max': 6.8752416381481787, 'min': 5.001801140108693} # lost: 1
limits['WH_tran/CC/dist/99.50'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['WH_tran/CC/dist/99.90'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['WH_tran/CC/dist/99.99'] = {'max': 6.8798985091465283, 'min': 5.001801140108693} # lost: 0
limits['WH_tran/CC/min_dist/100.00'] = {'max': 2.6923345874459881, 'min': 1.3683526247394959} # lost: 0
limits['WH_tran/CC/min_dist/95.00'] = {'max': 2.4872424945597169, 'min': 1.5521618580522534} # lost: 6
limits['WH_tran/CC/min_dist/99.00'] = {'max': 2.5621233210721228, 'min': 1.3683526247394959} # lost: 1
limits['WH_tran/CC/min_dist/99.50'] = {'max': 2.6923345874459881, 'min': 1.3683526247394959} # lost: 0
limits['WH_tran/CC/min_dist/99.90'] = {'max': 2.6923345874459881, 'min': 1.3683526247394959} # lost: 0
limits['WH_tran/CC/min_dist/99.99'] = {'max': 2.6923345874459881, 'min': 1.3683526247394959} # lost: 0
limits['WH_tran/CC/n2_z/100.00'] = {'max': -0.45343336, 'min': -0.99785691} # lost: 0
limits['WH_tran/CC/n2_z/95.00'] = {'max': -0.82083666, 'min': -0.99785691} # lost: 6
limits['WH_tran/CC/n2_z/99.00'] = {'max': -0.71166956, 'min': -0.99785691} # lost: 1
limits['WH_tran/CC/n2_z/99.50'] = {'max': -0.45343336, 'min': -0.99785691} # lost: 0
limits['WH_tran/CC/n2_z/99.90'] = {'max': -0.45343336, 'min': -0.99785691} # lost: 0
limits['WH_tran/CC/n2_z/99.99'] = {'max': -0.45343336, 'min': -0.99785691} # lost: 0
limits['WH_tran/CC/nn_ang_norm/100.00'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['WH_tran/CC/nn_ang_norm/95.00'] = {'max': 34.782692358198574, 'min': 2.180683147731969} # lost: 6
limits['WH_tran/CC/nn_ang_norm/99.00'] = {'max': 45.242730921101241, 'min': 2.180683147731969} # lost: 1
limits['WH_tran/CC/nn_ang_norm/99.50'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['WH_tran/CC/nn_ang_norm/99.90'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['WH_tran/CC/nn_ang_norm/99.99'] = {'max': 62.828418977133083, 'min': 2.180683147731969} # lost: 0
limits['WH_tran/CC/rot_ang/100.00'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['WH_tran/CC/rot_ang/95.00'] = {'max': 172.89913328603151, 'min': 130.59661166412661} # lost: 6
limits['WH_tran/CC/rot_ang/99.00'] = {'max': 182.04381121834876, 'min': 125.04704174030724} # lost: 1
limits['WH_tran/CC/rot_ang/99.50'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['WH_tran/CC/rot_ang/99.90'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['WH_tran/CC/rot_ang/99.99'] = {'max': 207.17150146697642, 'min': 125.04704174030724} # lost: 0
limits['WH_tran/CG/dist/100.00'] = {'max': 7.7615443595762574, 'min': 6.0170071217883248} # lost: 0
limits['WH_tran/CG/dist/95.00'] = {'max': 7.4578755980205091, 'min': 6.17217400032958} # lost: 12
limits['WH_tran/CG/dist/99.00'] = {'max': 7.5781591179198085, 'min': 6.0396475759791413} # lost: 2
limits['WH_tran/CG/dist/99.50'] = {'max': 7.5781591179198085, 'min': 6.0170071217883248} # lost: 1
limits['WH_tran/CG/dist/99.90'] = {'max': 7.7615443595762574, 'min': 6.0170071217883248} # lost: 0
limits['WH_tran/CG/dist/99.99'] = {'max': 7.7615443595762574, 'min': 6.0170071217883248} # lost: 0
limits['WH_tran/CG/min_dist/100.00'] = {'max': 2.7260556227006583, 'min': 1.1997770775387269} # lost: 0
limits['WH_tran/CG/min_dist/95.00'] = {'max': 2.6836913904281374, 'min': 1.5326564653443278} # lost: 12
limits['WH_tran/CG/min_dist/99.00'] = {'max': 2.7177809470109118, 'min': 1.3710438450653497} # lost: 2
limits['WH_tran/CG/min_dist/99.50'] = {'max': 2.7177809470109118, 'min': 1.1997770775387269} # lost: 1
limits['WH_tran/CG/min_dist/99.90'] = {'max': 2.7260556227006583, 'min': 1.1997770775387269} # lost: 0
limits['WH_tran/CG/min_dist/99.99'] = {'max': 2.7260556227006583, 'min': 1.1997770775387269} # lost: 0
limits['WH_tran/CG/n2_z/100.00'] = {'max': -0.48387715, 'min': -0.9997161} # lost: 0
limits['WH_tran/CG/n2_z/95.00'] = {'max': -0.82569665, 'min': -0.9997161} # lost: 12
limits['WH_tran/CG/n2_z/99.00'] = {'max': -0.62578493, 'min': -0.9997161} # lost: 2
limits['WH_tran/CG/n2_z/99.50'] = {'max': -0.55986416, 'min': -0.9997161} # lost: 1
limits['WH_tran/CG/n2_z/99.90'] = {'max': -0.48387715, 'min': -0.9997161} # lost: 0
limits['WH_tran/CG/n2_z/99.99'] = {'max': -0.48387715, 'min': -0.9997161} # lost: 0
limits['WH_tran/CG/nn_ang_norm/100.00'] = {'max': 59.993945113091144, 'min': 1.3369088984252926} # lost: 0
limits['WH_tran/CG/nn_ang_norm/95.00'] = {'max': 36.14543804102118, 'min': 1.3369088984252926} # lost: 12
limits['WH_tran/CG/nn_ang_norm/99.00'] = {'max': 51.819643016311574, 'min': 1.3369088984252926} # lost: 2
limits['WH_tran/CG/nn_ang_norm/99.50'] = {'max': 55.6968955213177, 'min': 1.3369088984252926} # lost: 1
limits['WH_tran/CG/nn_ang_norm/99.90'] = {'max': 59.993945113091144, 'min': 1.3369088984252926} # lost: 0
limits['WH_tran/CG/nn_ang_norm/99.99'] = {'max': 59.993945113091144, 'min': 1.3369088984252926} # lost: 0
limits['WH_tran/CG/rot_ang/100.00'] = {'max': 210.83460045495534, 'min': 141.9565148544327} # lost: 0
limits['WH_tran/CG/rot_ang/95.00'] = {'max': 198.05353408233887, 'min': 147.82045152562219} # lost: 12
limits['WH_tran/CG/rot_ang/99.00'] = {'max': 207.25140357764482, 'min': 142.2759521433133} # lost: 2
limits['WH_tran/CG/rot_ang/99.50'] = {'max': 207.25140357764482, 'min': 141.9565148544327} # lost: 1
limits['WH_tran/CG/rot_ang/99.90'] = {'max': 210.83460045495534, 'min': 141.9565148544327} # lost: 0
limits['WH_tran/CG/rot_ang/99.99'] = {'max': 210.83460045495534, 'min': 141.9565148544327} # lost: 0
limits['WH_tran/CU/dist/100.00'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['WH_tran/CU/dist/95.00'] = {'max': 7.3165018350439155, 'min': 5.571139950170604} # lost: 1
limits['WH_tran/CU/dist/99.00'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['WH_tran/CU/dist/99.50'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['WH_tran/CU/dist/99.90'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['WH_tran/CU/dist/99.99'] = {'max': 7.364728186987775, 'min': 5.571139950170604} # lost: 0
limits['WH_tran/CU/min_dist/100.00'] = {'max': 2.3199042363026345, 'min': 0.5345084699264292} # lost: 0
limits['WH_tran/CU/min_dist/95.00'] = {'max': 2.2627662275192111, 'min': 0.5345084699264292} # lost: 1
limits['WH_tran/CU/min_dist/99.00'] = {'max': 2.3199042363026345, 'min': 0.5345084699264292} # lost: 0
limits['WH_tran/CU/min_dist/99.50'] = {'max': 2.3199042363026345, 'min': 0.5345084699264292} # lost: 0
limits['WH_tran/CU/min_dist/99.90'] = {'max': 2.3199042363026345, 'min': 0.5345084699264292} # lost: 0
limits['WH_tran/CU/min_dist/99.99'] = {'max': 2.3199042363026345, 'min': 0.5345084699264292} # lost: 0
limits['WH_tran/CU/n2_z/100.00'] = {'max': -0.74776876, 'min': -0.99767429} # lost: 0
limits['WH_tran/CU/n2_z/95.00'] = {'max': -0.78747439, 'min': -0.99767429} # lost: 1
limits['WH_tran/CU/n2_z/99.00'] = {'max': -0.74776876, 'min': -0.99767429} # lost: 0
limits['WH_tran/CU/n2_z/99.50'] = {'max': -0.74776876, 'min': -0.99767429} # lost: 0
limits['WH_tran/CU/n2_z/99.90'] = {'max': -0.74776876, 'min': -0.99767429} # lost: 0
limits['WH_tran/CU/n2_z/99.99'] = {'max': -0.74776876, 'min': -0.99767429} # lost: 0
limits['WH_tran/CU/nn_ang_norm/100.00'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['WH_tran/CU/nn_ang_norm/95.00'] = {'max': 37.908596733746606, 'min': 3.8241359450637731} # lost: 1
limits['WH_tran/CU/nn_ang_norm/99.00'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['WH_tran/CU/nn_ang_norm/99.50'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['WH_tran/CU/nn_ang_norm/99.90'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['WH_tran/CU/nn_ang_norm/99.99'] = {'max': 42.830157842091012, 'min': 3.8241359450637731} # lost: 0
limits['WH_tran/CU/rot_ang/100.00'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['WH_tran/CU/rot_ang/95.00'] = {'max': 168.92397879795305, 'min': 146.34327291062843} # lost: 1
limits['WH_tran/CU/rot_ang/99.00'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['WH_tran/CU/rot_ang/99.50'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['WH_tran/CU/rot_ang/99.90'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['WH_tran/CU/rot_ang/99.99'] = {'max': 194.60165036125369, 'min': 146.34327291062843} # lost: 0
limits['WH_tran/GA/dist/100.00'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['WH_tran/GA/dist/95.00'] = {'max': 8.1390553818236189, 'min': 6.0153605887810571} # lost: 6
limits['WH_tran/GA/dist/99.00'] = {'max': 8.198340272320932, 'min': 5.459736786735025} # lost: 1
limits['WH_tran/GA/dist/99.50'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['WH_tran/GA/dist/99.90'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['WH_tran/GA/dist/99.99'] = {'max': 8.2113326485508527, 'min': 5.459736786735025} # lost: 0
limits['WH_tran/GA/min_dist/100.00'] = {'max': 2.3858979592289806, 'min': 0.8474532051953555} # lost: 0
limits['WH_tran/GA/min_dist/95.00'] = {'max': 2.3458438422738213, 'min': 0.99564774843711901} # lost: 6
limits['WH_tran/GA/min_dist/99.00'] = {'max': 2.364291033054625, 'min': 0.8474532051953555} # lost: 1
limits['WH_tran/GA/min_dist/99.50'] = {'max': 2.3858979592289806, 'min': 0.8474532051953555} # lost: 0
limits['WH_tran/GA/min_dist/99.90'] = {'max': 2.3858979592289806, 'min': 0.8474532051953555} # lost: 0
limits['WH_tran/GA/min_dist/99.99'] = {'max': 2.3858979592289806, 'min': 0.8474532051953555} # lost: 0
limits['WH_tran/GA/n2_z/100.00'] = {'max': -0.48008355, 'min': -0.9988268} # lost: 0
limits['WH_tran/GA/n2_z/95.00'] = {'max': -0.74822617, 'min': -0.9988268} # lost: 6
limits['WH_tran/GA/n2_z/99.00'] = {'max': -0.59034377, 'min': -0.9988268} # lost: 1
limits['WH_tran/GA/n2_z/99.50'] = {'max': -0.48008355, 'min': -0.9988268} # lost: 0
limits['WH_tran/GA/n2_z/99.90'] = {'max': -0.48008355, 'min': -0.9988268} # lost: 0
limits['WH_tran/GA/n2_z/99.99'] = {'max': -0.48008355, 'min': -0.9988268} # lost: 0
limits['WH_tran/GA/nn_ang_norm/100.00'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['WH_tran/GA/nn_ang_norm/95.00'] = {'max': 41.701346138341336, 'min': 2.9914675833475144} # lost: 6
limits['WH_tran/GA/nn_ang_norm/99.00'] = {'max': 53.843783237223207, 'min': 2.9914675833475144} # lost: 1
limits['WH_tran/GA/nn_ang_norm/99.50'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['WH_tran/GA/nn_ang_norm/99.90'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['WH_tran/GA/nn_ang_norm/99.99'] = {'max': 61.320927925419568, 'min': 2.9914675833475144} # lost: 0
limits['WH_tran/GA/rot_ang/100.00'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['WH_tran/GA/rot_ang/95.00'] = {'max': 201.28629099718589, 'min': 126.44908207696861} # lost: 6
limits['WH_tran/GA/rot_ang/99.00'] = {'max': 207.61404296689827, 'min': 104.46383412471042} # lost: 1
limits['WH_tran/GA/rot_ang/99.50'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['WH_tran/GA/rot_ang/99.90'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['WH_tran/GA/rot_ang/99.99'] = {'max': 208.30550660097239, 'min': 104.46383412471042} # lost: 0
limits['WH_tran/GC/dist/100.00'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['WH_tran/GC/dist/95.00'] = {'max': 7.3451477984825519, 'min': 5.4965649412574979} # lost: 2
limits['WH_tran/GC/dist/99.00'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['WH_tran/GC/dist/99.50'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['WH_tran/GC/dist/99.90'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['WH_tran/GC/dist/99.99'] = {'max': 7.3909727069463678, 'min': 5.4830326222251058} # lost: 0
limits['WH_tran/GC/min_dist/100.00'] = {'max': 2.1573687533934334, 'min': 0.73873325576318305} # lost: 0
limits['WH_tran/GC/min_dist/95.00'] = {'max': 2.099372073384921, 'min': 0.7585455676353956} # lost: 2
limits['WH_tran/GC/min_dist/99.00'] = {'max': 2.1573687533934334, 'min': 0.73873325576318305} # lost: 0
limits['WH_tran/GC/min_dist/99.50'] = {'max': 2.1573687533934334, 'min': 0.73873325576318305} # lost: 0
limits['WH_tran/GC/min_dist/99.90'] = {'max': 2.1573687533934334, 'min': 0.73873325576318305} # lost: 0
limits['WH_tran/GC/min_dist/99.99'] = {'max': 2.1573687533934334, 'min': 0.73873325576318305} # lost: 0
limits['WH_tran/GC/n2_z/100.00'] = {'max': -0.50038534, 'min': -0.9940263} # lost: 0
limits['WH_tran/GC/n2_z/95.00'] = {'max': -0.63288552, 'min': -0.9940263} # lost: 2
limits['WH_tran/GC/n2_z/99.00'] = {'max': -0.50038534, 'min': -0.9940263} # lost: 0
limits['WH_tran/GC/n2_z/99.50'] = {'max': -0.50038534, 'min': -0.9940263} # lost: 0
limits['WH_tran/GC/n2_z/99.90'] = {'max': -0.50038534, 'min': -0.9940263} # lost: 0
limits['WH_tran/GC/n2_z/99.99'] = {'max': -0.50038534, 'min': -0.9940263} # lost: 0
limits['WH_tran/GC/nn_ang_norm/100.00'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['WH_tran/GC/nn_ang_norm/95.00'] = {'max': 50.733301428821051, 'min': 4.6861331390760483} # lost: 2
limits['WH_tran/GC/nn_ang_norm/99.00'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['WH_tran/GC/nn_ang_norm/99.50'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['WH_tran/GC/nn_ang_norm/99.90'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['WH_tran/GC/nn_ang_norm/99.99'] = {'max': 59.957348959518214, 'min': 4.6861331390760483} # lost: 0
limits['WH_tran/GC/rot_ang/100.00'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['WH_tran/GC/rot_ang/95.00'] = {'max': 204.12031521835675, 'min': 156.66953390161615} # lost: 2
limits['WH_tran/GC/rot_ang/99.00'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['WH_tran/GC/rot_ang/99.50'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['WH_tran/GC/rot_ang/99.90'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['WH_tran/GC/rot_ang/99.99'] = {'max': 204.60531457142537, 'min': 156.23618998096035} # lost: 0
limits['WH_tran/GG/dist/100.00'] = {'max': 7.8071466553036117, 'min': 5.5257457943629085} # lost: 0
limits['WH_tran/GG/dist/95.00'] = {'max': 7.3840221867671101, 'min': 5.84081257631426} # lost: 36
limits['WH_tran/GG/dist/99.00'] = {'max': 7.5458386568720508, 'min': 5.6951075727408433} # lost: 7
limits['WH_tran/GG/dist/99.50'] = {'max': 7.6247866597428509, 'min': 5.6194769503052253} # lost: 3
limits['WH_tran/GG/dist/99.90'] = {'max': 7.8071466553036117, 'min': 5.5257457943629085} # lost: 0
limits['WH_tran/GG/dist/99.99'] = {'max': 7.8071466553036117, 'min': 5.5257457943629085} # lost: 0
limits['WH_tran/GG/min_dist/100.00'] = {'max': 2.661344459593475, 'min': 1.0508507406321472} # lost: 0
limits['WH_tran/GG/min_dist/95.00'] = {'max': 2.4081583015135348, 'min': 1.5378524855936739} # lost: 36
limits['WH_tran/GG/min_dist/99.00'] = {'max': 2.5238935882189191, 'min': 1.2146852958105083} # lost: 7
limits['WH_tran/GG/min_dist/99.50'] = {'max': 2.5298320896985391, 'min': 1.1063967224036877} # lost: 3
limits['WH_tran/GG/min_dist/99.90'] = {'max': 2.661344459593475, 'min': 1.0508507406321472} # lost: 0
limits['WH_tran/GG/min_dist/99.99'] = {'max': 2.661344459593475, 'min': 1.0508507406321472} # lost: 0
limits['WH_tran/GG/n2_z/100.00'] = {'max': -0.42652223, 'min': -0.99990946} # lost: 0
limits['WH_tran/GG/n2_z/95.00'] = {'max': -0.50937152, 'min': -0.99990946} # lost: 36
limits['WH_tran/GG/n2_z/99.00'] = {'max': -0.4426415, 'min': -0.99990946} # lost: 7
limits['WH_tran/GG/n2_z/99.50'] = {'max': -0.43267867, 'min': -0.99990946} # lost: 3
limits['WH_tran/GG/n2_z/99.90'] = {'max': -0.42652223, 'min': -0.99990946} # lost: 0
limits['WH_tran/GG/n2_z/99.99'] = {'max': -0.42652223, 'min': -0.99990946} # lost: 0
limits['WH_tran/GG/nn_ang_norm/100.00'] = {'max': 64.672542732279837, 'min': 0.60620160063896833} # lost: 0
limits['WH_tran/GG/nn_ang_norm/95.00'] = {'max': 59.834760724294824, 'min': 0.60620160063896833} # lost: 36
limits['WH_tran/GG/nn_ang_norm/99.00'] = {'max': 63.614286882656401, 'min': 0.60620160063896833} # lost: 7
limits['WH_tran/GG/nn_ang_norm/99.50'] = {'max': 63.96974358744221, 'min': 0.60620160063896833} # lost: 3
limits['WH_tran/GG/nn_ang_norm/99.90'] = {'max': 64.672542732279837, 'min': 0.60620160063896833} # lost: 0
limits['WH_tran/GG/nn_ang_norm/99.99'] = {'max': 64.672542732279837, 'min': 0.60620160063896833} # lost: 0
limits['WH_tran/GG/rot_ang/100.00'] = {'max': 233.55429160056622, 'min': 124.02435049132643} # lost: 0
limits['WH_tran/GG/rot_ang/95.00'] = {'max': 195.91744237793134, 'min': 134.9343931639294} # lost: 36
limits['WH_tran/GG/rot_ang/99.00'] = {'max': 204.47913846115063, 'min': 128.49244101108715} # lost: 7
limits['WH_tran/GG/rot_ang/99.50'] = {'max': 204.87066471173125, 'min': 124.6166265069652} # lost: 3
limits['WH_tran/GG/rot_ang/99.90'] = {'max': 233.55429160056622, 'min': 124.02435049132643} # lost: 0
limits['WH_tran/GG/rot_ang/99.99'] = {'max': 233.55429160056622, 'min': 124.02435049132643} # lost: 0
limits['WH_tran/GU/dist/100.00'] = {'max': 6.9598799254501582, 'min': 5.447965287801865} # lost: 0
limits['WH_tran/GU/dist/95.00'] = {'max': 6.5562178546854346, 'min': 5.5505610617786738} # lost: 10
limits['WH_tran/GU/dist/99.00'] = {'max': 6.6741481954779189, 'min': 5.5217602393792049} # lost: 2
limits['WH_tran/GU/dist/99.50'] = {'max': 6.6741481954779189, 'min': 5.447965287801865} # lost: 1
limits['WH_tran/GU/dist/99.90'] = {'max': 6.9598799254501582, 'min': 5.447965287801865} # lost: 0
limits['WH_tran/GU/dist/99.99'] = {'max': 6.9598799254501582, 'min': 5.447965287801865} # lost: 0
limits['WH_tran/GU/min_dist/100.00'] = {'max': 2.5638790003081762, 'min': 0.91781254193315764} # lost: 0
limits['WH_tran/GU/min_dist/95.00'] = {'max': 2.4728752086786163, 'min': 1.3826222280213005} # lost: 10
limits['WH_tran/GU/min_dist/99.00'] = {'max': 2.5534015866304176, 'min': 1.1467707772311815} # lost: 2
limits['WH_tran/GU/min_dist/99.50'] = {'max': 2.5534015866304176, 'min': 0.91781254193315764} # lost: 1
limits['WH_tran/GU/min_dist/99.90'] = {'max': 2.5638790003081762, 'min': 0.91781254193315764} # lost: 0
limits['WH_tran/GU/min_dist/99.99'] = {'max': 2.5638790003081762, 'min': 0.91781254193315764} # lost: 0
limits['WH_tran/GU/n2_z/100.00'] = {'max': -0.4474895, 'min': -0.99735224} # lost: 0
limits['WH_tran/GU/n2_z/95.00'] = {'max': -0.46914455, 'min': -0.99735224} # lost: 10
limits['WH_tran/GU/n2_z/99.00'] = {'max': -0.44819257, 'min': -0.99735224} # lost: 2
limits['WH_tran/GU/n2_z/99.50'] = {'max': -0.44789121, 'min': -0.99735224} # lost: 1
limits['WH_tran/GU/n2_z/99.90'] = {'max': -0.4474895, 'min': -0.99735224} # lost: 0
limits['WH_tran/GU/n2_z/99.99'] = {'max': -0.4474895, 'min': -0.99735224} # lost: 0
limits['WH_tran/GU/nn_ang_norm/100.00'] = {'max': 63.471822796948274, 'min': 4.4979341066855341} # lost: 0
limits['WH_tran/GU/nn_ang_norm/95.00'] = {'max': 61.953567367102821, 'min': 4.4979341066855341} # lost: 10
limits['WH_tran/GU/nn_ang_norm/99.00'] = {'max': 63.232151458972538, 'min': 4.4979341066855341} # lost: 2
limits['WH_tran/GU/nn_ang_norm/99.50'] = {'max': 63.468380381606593, 'min': 4.4979341066855341} # lost: 1
limits['WH_tran/GU/nn_ang_norm/99.90'] = {'max': 63.471822796948274, 'min': 4.4979341066855341} # lost: 0
limits['WH_tran/GU/nn_ang_norm/99.99'] = {'max': 63.471822796948274, 'min': 4.4979341066855341} # lost: 0
limits['WH_tran/GU/rot_ang/100.00'] = {'max': 203.34145325660455, 'min': 135.21745931345157} # lost: 0
limits['WH_tran/GU/rot_ang/95.00'] = {'max': 191.85946010086872, 'min': 145.58777433620571} # lost: 10
limits['WH_tran/GU/rot_ang/99.00'] = {'max': 195.52280391289747, 'min': 142.77818911927014} # lost: 2
limits['WH_tran/GU/rot_ang/99.50'] = {'max': 195.52280391289747, 'min': 135.21745931345157} # lost: 1
limits['WH_tran/GU/rot_ang/99.90'] = {'max': 203.34145325660455, 'min': 135.21745931345157} # lost: 0
limits['WH_tran/GU/rot_ang/99.99'] = {'max': 203.34145325660455, 'min': 135.21745931345157} # lost: 0
limits['WH_tran/UA/dist/100.00'] = {'max': 7.5791695769343397, 'min': 5.3784864080613959} # lost: 0
limits['WH_tran/UA/dist/95.00'] = {'max': 7.0136329407869864, 'min': 6.1516119274546019} # lost: 744
limits['WH_tran/UA/dist/99.00'] = {'max': 7.255761533270932, 'min': 5.9745780530802417} # lost: 148
limits['WH_tran/UA/dist/99.50'] = {'max': 7.368886096933716, 'min': 5.9072392905607174} # lost: 74
limits['WH_tran/UA/dist/99.90'] = {'max': 7.4908629422789463, 'min': 5.7858036205310466} # lost: 14
limits['WH_tran/UA/dist/99.99'] = {'max': 7.5753404331476837, 'min': 5.3784864080613959} # lost: 1
limits['WH_tran/UA/min_dist/100.00'] = {'max': 2.7961175701860905, 'min': 0.65012694769429624} # lost: 0
limits['WH_tran/UA/min_dist/95.00'] = {'max': 2.3078422532709038, 'min': 1.5045088263332835} # lost: 744
limits['WH_tran/UA/min_dist/99.00'] = {'max': 2.4851900153768995, 'min': 1.2696457976651265} # lost: 148
limits['WH_tran/UA/min_dist/99.50'] = {'max': 2.538022832193914, 'min': 1.1648815042365812} # lost: 74
limits['WH_tran/UA/min_dist/99.90'] = {'max': 2.6608886049879632, 'min': 0.94951962467887752} # lost: 14
limits['WH_tran/UA/min_dist/99.99'] = {'max': 2.7924013805226591, 'min': 0.65012694769429624} # lost: 1
limits['WH_tran/UA/n2_z/100.00'] = {'max': -0.42248955, 'min': -0.9999994} # lost: 0
limits['WH_tran/UA/n2_z/95.00'] = {'max': -0.80135244, 'min': -0.9999994} # lost: 744
limits['WH_tran/UA/n2_z/99.00'] = {'max': -0.59974879, 'min': -0.9999994} # lost: 148
limits['WH_tran/UA/n2_z/99.50'] = {'max': -0.54422134, 'min': -0.9999994} # lost: 74
limits['WH_tran/UA/n2_z/99.90'] = {'max': -0.46283174, 'min': -0.9999994} # lost: 14
limits['WH_tran/UA/n2_z/99.99'] = {'max': -0.42815992, 'min': -0.9999994} # lost: 1
limits['WH_tran/UA/nn_ang_norm/100.00'] = {'max': 64.974191206784283, 'min': 0.044240956487016092} # lost: 0
limits['WH_tran/UA/nn_ang_norm/95.00'] = {'max': 36.700500194111441, 'min': 0.044240956487016092} # lost: 744
limits['WH_tran/UA/nn_ang_norm/99.00'] = {'max': 53.015131026738914, 'min': 0.044240956487016092} # lost: 148
limits['WH_tran/UA/nn_ang_norm/99.50'] = {'max': 57.114514943932193, 'min': 0.044240956487016092} # lost: 74
limits['WH_tran/UA/nn_ang_norm/99.90'] = {'max': 62.447622270526523, 'min': 0.044240956487016092} # lost: 14
limits['WH_tran/UA/nn_ang_norm/99.99'] = {'max': 64.346578784330148, 'min': 0.044240956487016092} # lost: 1
limits['WH_tran/UA/rot_ang/100.00'] = {'max': 209.22466754589814, 'min': 127.65819618729412} # lost: 0
limits['WH_tran/UA/rot_ang/95.00'] = {'max': 181.85328338560683, 'min': 149.93992334333683} # lost: 744
limits['WH_tran/UA/rot_ang/99.00'] = {'max': 189.4844673968295, 'min': 142.66168402343195} # lost: 148
limits['WH_tran/UA/rot_ang/99.50'] = {'max': 192.72087195982235, 'min': 141.52364974803285} # lost: 74
limits['WH_tran/UA/rot_ang/99.90'] = {'max': 197.80785795310652, 'min': 134.09886431618077} # lost: 14
limits['WH_tran/UA/rot_ang/99.99'] = {'max': 202.69379069489963, 'min': 127.65819618729412} # lost: 1
limits['WH_tran/UC/dist/100.00'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['WH_tran/UC/dist/95.00'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['WH_tran/UC/dist/99.00'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['WH_tran/UC/dist/99.50'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['WH_tran/UC/dist/99.90'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['WH_tran/UC/dist/99.99'] = {'max': 6.7928932984552226, 'min': 5.4219501136722457} # lost: 0
limits['WH_tran/UC/min_dist/100.00'] = {'max': 2.4053511049660652, 'min': 1.1478059664197984} # lost: 0
limits['WH_tran/UC/min_dist/95.00'] = {'max': 2.4053511049660652, 'min': 1.1478059664197984} # lost: 0
limits['WH_tran/UC/min_dist/99.00'] = {'max': 2.4053511049660652, 'min': 1.1478059664197984} # lost: 0
limits['WH_tran/UC/min_dist/99.50'] = {'max': 2.4053511049660652, 'min': 1.1478059664197984} # lost: 0
limits['WH_tran/UC/min_dist/99.90'] = {'max': 2.4053511049660652, 'min': 1.1478059664197984} # lost: 0
limits['WH_tran/UC/min_dist/99.99'] = {'max': 2.4053511049660652, 'min': 1.1478059664197984} # lost: 0
limits['WH_tran/UC/n2_z/100.00'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['WH_tran/UC/n2_z/95.00'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['WH_tran/UC/n2_z/99.00'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['WH_tran/UC/n2_z/99.50'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['WH_tran/UC/n2_z/99.90'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['WH_tran/UC/n2_z/99.99'] = {'max': -0.78868204, 'min': -0.97309524} # lost: 0
limits['WH_tran/UC/nn_ang_norm/100.00'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['WH_tran/UC/nn_ang_norm/95.00'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['WH_tran/UC/nn_ang_norm/99.00'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['WH_tran/UC/nn_ang_norm/99.50'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['WH_tran/UC/nn_ang_norm/99.90'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['WH_tran/UC/nn_ang_norm/99.99'] = {'max': 37.88680843029428, 'min': 12.82194028969343} # lost: 0
limits['WH_tran/UC/rot_ang/100.00'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['WH_tran/UC/rot_ang/95.00'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['WH_tran/UC/rot_ang/99.00'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['WH_tran/UC/rot_ang/99.50'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['WH_tran/UC/rot_ang/99.90'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['WH_tran/UC/rot_ang/99.99'] = {'max': 178.09423593038909, 'min': 134.66160898001706} # lost: 0
limits['WH_tran/UG/dist/100.00'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['WH_tran/UG/dist/95.00'] = {'max': 7.4619309258926663, 'min': 6.1307417301528115} # lost: 2
limits['WH_tran/UG/dist/99.00'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['WH_tran/UG/dist/99.50'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['WH_tran/UG/dist/99.90'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['WH_tran/UG/dist/99.99'] = {'max': 7.4741879979346963, 'min': 6.035699683004073} # lost: 0
limits['WH_tran/UG/min_dist/100.00'] = {'max': 2.644688700452908, 'min': 1.6552218257471445} # lost: 0
limits['WH_tran/UG/min_dist/95.00'] = {'max': 2.6241263849557632, 'min': 1.6833002189153583} # lost: 2
limits['WH_tran/UG/min_dist/99.00'] = {'max': 2.644688700452908, 'min': 1.6552218257471445} # lost: 0
limits['WH_tran/UG/min_dist/99.50'] = {'max': 2.644688700452908, 'min': 1.6552218257471445} # lost: 0
limits['WH_tran/UG/min_dist/99.90'] = {'max': 2.644688700452908, 'min': 1.6552218257471445} # lost: 0
limits['WH_tran/UG/min_dist/99.99'] = {'max': 2.644688700452908, 'min': 1.6552218257471445} # lost: 0
limits['WH_tran/UG/n2_z/100.00'] = {'max': -0.63674343, 'min': -0.99921179} # lost: 0
limits['WH_tran/UG/n2_z/95.00'] = {'max': -0.77130014, 'min': -0.99921179} # lost: 2
limits['WH_tran/UG/n2_z/99.00'] = {'max': -0.63674343, 'min': -0.99921179} # lost: 0
limits['WH_tran/UG/n2_z/99.50'] = {'max': -0.63674343, 'min': -0.99921179} # lost: 0
limits['WH_tran/UG/n2_z/99.90'] = {'max': -0.63674343, 'min': -0.99921179} # lost: 0
limits['WH_tran/UG/n2_z/99.99'] = {'max': -0.63674343, 'min': -0.99921179} # lost: 0
limits['WH_tran/UG/nn_ang_norm/100.00'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['WH_tran/UG/nn_ang_norm/95.00'] = {'max': 39.611772705180982, 'min': 3.1713201245722757} # lost: 2
limits['WH_tran/UG/nn_ang_norm/99.00'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['WH_tran/UG/nn_ang_norm/99.50'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['WH_tran/UG/nn_ang_norm/99.90'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['WH_tran/UG/nn_ang_norm/99.99'] = {'max': 48.861023633915494, 'min': 3.1713201245722757} # lost: 0
limits['WH_tran/UG/rot_ang/100.00'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['WH_tran/UG/rot_ang/95.00'] = {'max': 210.52274912595155, 'min': 154.34850734596756} # lost: 2
limits['WH_tran/UG/rot_ang/99.00'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['WH_tran/UG/rot_ang/99.50'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['WH_tran/UG/rot_ang/99.90'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['WH_tran/UG/rot_ang/99.99'] = {'max': 210.83327303391303, 'min': 151.9201254668582} # lost: 0
limits['WH_tran/UU/dist/100.00'] = {'max': 6.8388242888229929, 'min': 5.2257914636473135} # lost: 0
limits['WH_tran/UU/dist/95.00'] = {'max': 6.55423341372052, 'min': 5.7054975384290767} # lost: 30
limits['WH_tran/UU/dist/99.00'] = {'max': 6.6529998507131332, 'min': 5.3929379872354861} # lost: 6
limits['WH_tran/UU/dist/99.50'] = {'max': 6.7346619126959517, 'min': 5.3030069567626557} # lost: 3
limits['WH_tran/UU/dist/99.90'] = {'max': 6.8388242888229929, 'min': 5.2257914636473135} # lost: 0
limits['WH_tran/UU/dist/99.99'] = {'max': 6.8388242888229929, 'min': 5.2257914636473135} # lost: 0
limits['WH_tran/UU/min_dist/100.00'] = {'max': 2.4284344848131898, 'min': 0.91569698843497871} # lost: 0
limits['WH_tran/UU/min_dist/95.00'] = {'max': 2.2819516457804707, 'min': 1.4123716046955732} # lost: 30
limits['WH_tran/UU/min_dist/99.00'] = {'max': 2.3482952066678107, 'min': 1.1958143165260897} # lost: 6
limits['WH_tran/UU/min_dist/99.50'] = {'max': 2.3540047585766466, 'min': 1.098148716917128} # lost: 3
limits['WH_tran/UU/min_dist/99.90'] = {'max': 2.4284344848131898, 'min': 0.91569698843497871} # lost: 0
limits['WH_tran/UU/min_dist/99.99'] = {'max': 2.4284344848131898, 'min': 0.91569698843497871} # lost: 0
limits['WH_tran/UU/n2_z/100.00'] = {'max': -0.45606229, 'min': -0.99942976} # lost: 0
limits['WH_tran/UU/n2_z/95.00'] = {'max': -0.7889033, 'min': -0.99942976} # lost: 30
limits['WH_tran/UU/n2_z/99.00'] = {'max': -0.6368109, 'min': -0.99942976} # lost: 6
limits['WH_tran/UU/n2_z/99.50'] = {'max': -0.59405774, 'min': -0.99942976} # lost: 3
limits['WH_tran/UU/n2_z/99.90'] = {'max': -0.45606229, 'min': -0.99942976} # lost: 0
limits['WH_tran/UU/n2_z/99.99'] = {'max': -0.45606229, 'min': -0.99942976} # lost: 0
limits['WH_tran/UU/nn_ang_norm/100.00'] = {'max': 62.326304450488763, 'min': 1.9444132439628845} # lost: 0
limits['WH_tran/UU/nn_ang_norm/95.00'] = {'max': 37.506558138821333, 'min': 1.9444132439628845} # lost: 30
limits['WH_tran/UU/nn_ang_norm/99.00'] = {'max': 49.414719749171752, 'min': 1.9444132439628845} # lost: 6
limits['WH_tran/UU/nn_ang_norm/99.50'] = {'max': 53.692016433865518, 'min': 1.9444132439628845} # lost: 3
limits['WH_tran/UU/nn_ang_norm/99.90'] = {'max': 62.326304450488763, 'min': 1.9444132439628845} # lost: 0
limits['WH_tran/UU/nn_ang_norm/99.99'] = {'max': 62.326304450488763, 'min': 1.9444132439628845} # lost: 0
limits['WH_tran/UU/rot_ang/100.00'] = {'max': 204.39711019187692, 'min': 134.87072698425607} # lost: 0
limits['WH_tran/UU/rot_ang/95.00'] = {'max': 176.48322335101449, 'min': 142.03490065250426} # lost: 30
limits['WH_tran/UU/rot_ang/99.00'] = {'max': 190.59934224804704, 'min': 138.97629704528509} # lost: 6
limits['WH_tran/UU/rot_ang/99.50'] = {'max': 190.64216104216425, 'min': 138.55649370136905} # lost: 3
limits['WH_tran/UU/rot_ang/99.90'] = {'max': 204.39711019187692, 'min': 134.87072698425607} # lost: 0
limits['WH_tran/UU/rot_ang/99.99'] = {'max': 204.39711019187692, 'min': 134.87072698425607} # lost: 0
limits['WS_cis/AA/dist/100.00'] = {'max': 7.4255924863873135, 'min': 4.4335114541928649} # lost: 0
limits['WS_cis/AA/dist/95.00'] = {'max': 7.1694772586882447, 'min': 6.2024663838415739} # lost: 72
limits['WS_cis/AA/dist/99.00'] = {'max': 7.2683443096103959, 'min': 5.8590972608083876} # lost: 14
limits['WS_cis/AA/dist/99.50'] = {'max': 7.3178979161985325, 'min': 5.2823017040658051} # lost: 7
limits['WS_cis/AA/dist/99.90'] = {'max': 7.368408688668298, 'min': 4.4335114541928649} # lost: 1
limits['WS_cis/AA/dist/99.99'] = {'max': 7.4255924863873135, 'min': 4.4335114541928649} # lost: 0
limits['WS_cis/AA/min_dist/100.00'] = {'max': 2.731270555872408, 'min': 1.1887792457030282} # lost: 0
limits['WS_cis/AA/min_dist/95.00'] = {'max': 2.5412524867685691, 'min': 1.7567224690426142} # lost: 72
limits['WS_cis/AA/min_dist/99.00'] = {'max': 2.6702486957343075, 'min': 1.535656736538072} # lost: 14
limits['WS_cis/AA/min_dist/99.50'] = {'max': 2.7020087119215592, 'min': 1.4573392153825386} # lost: 7
limits['WS_cis/AA/min_dist/99.90'] = {'max': 2.728270599790708, 'min': 1.1887792457030282} # lost: 1
limits['WS_cis/AA/min_dist/99.99'] = {'max': 2.731270555872408, 'min': 1.1887792457030282} # lost: 0
limits['WS_cis/AA/n2_z/100.00'] = {'max': -0.45555472, 'min': -0.9999764} # lost: 0
limits['WS_cis/AA/n2_z/95.00'] = {'max': -0.74369842, 'min': -0.9999764} # lost: 72
limits['WS_cis/AA/n2_z/99.00'] = {'max': -0.61306417, 'min': -0.9999764} # lost: 14
limits['WS_cis/AA/n2_z/99.50'] = {'max': -0.565229, 'min': -0.9999764} # lost: 7
limits['WS_cis/AA/n2_z/99.90'] = {'max': -0.45557645, 'min': -0.9999764} # lost: 1
limits['WS_cis/AA/n2_z/99.99'] = {'max': -0.45555472, 'min': -0.9999764} # lost: 0
limits['WS_cis/AA/nn_ang_norm/100.00'] = {'max': 63.540220311296792, 'min': 0.31090520206265637} # lost: 0
limits['WS_cis/AA/nn_ang_norm/95.00'] = {'max': 42.017829783723045, 'min': 0.31090520206265637} # lost: 72
limits['WS_cis/AA/nn_ang_norm/99.00'] = {'max': 52.24900236791693, 'min': 0.31090520206265637} # lost: 14
limits['WS_cis/AA/nn_ang_norm/99.50'] = {'max': 55.68721031307463, 'min': 0.31090520206265637} # lost: 7
limits['WS_cis/AA/nn_ang_norm/99.90'] = {'max': 62.625125226676815, 'min': 0.31090520206265637} # lost: 1
limits['WS_cis/AA/nn_ang_norm/99.99'] = {'max': 63.540220311296792, 'min': 0.31090520206265637} # lost: 0
limits['WS_cis/AA/rot_ang/100.00'] = {'max': 65.90603320393619, 'min': -64.485632004671203} # lost: 0
limits['WS_cis/AA/rot_ang/95.00'] = {'max': 51.065395465049669, 'min': 13.477793118452745} # lost: 72
limits['WS_cis/AA/rot_ang/99.00'] = {'max': 58.706354175549265, 'min': -37.294849861049705} # lost: 14
limits['WS_cis/AA/rot_ang/99.50'] = {'max': 65.865818892568484, 'min': -53.98451477673288} # lost: 7
limits['WS_cis/AA/rot_ang/99.90'] = {'max': 65.902051971697261, 'min': -64.485632004671203} # lost: 1
limits['WS_cis/AA/rot_ang/99.99'] = {'max': 65.90603320393619, 'min': -64.485632004671203} # lost: 0
limits['WS_cis/AC/dist/100.00'] = {'max': 8.2618641635859245, 'min': 6.0458700554917071} # lost: 0
limits['WS_cis/AC/dist/95.00'] = {'max': 7.8750312780340996, 'min': 6.8831735173044883} # lost: 103
limits['WS_cis/AC/dist/99.00'] = {'max': 8.0664424900058016, 'min': 6.6586824767919843} # lost: 20
limits['WS_cis/AC/dist/99.50'] = {'max': 8.1623993182714258, 'min': 6.3370383140674313} # lost: 10
limits['WS_cis/AC/dist/99.90'] = {'max': 8.2013781901452223, 'min': 6.0823199351927428} # lost: 2
limits['WS_cis/AC/dist/99.99'] = {'max': 8.2618641635859245, 'min': 6.0458700554917071} # lost: 0
limits['WS_cis/AC/min_dist/100.00'] = {'max': 2.8549822829340976, 'min': 1.2151564323117876} # lost: 0
limits['WS_cis/AC/min_dist/95.00'] = {'max': 2.4890963373837169, 'min': 1.5344420234056206} # lost: 103
limits['WS_cis/AC/min_dist/99.00'] = {'max': 2.6192407575843908, 'min': 1.3931260954891436} # lost: 20
limits['WS_cis/AC/min_dist/99.50'] = {'max': 2.6562845409661637, 'min': 1.2873215574350607} # lost: 10
limits['WS_cis/AC/min_dist/99.90'] = {'max': 2.7163732540312635, 'min': 1.2157998443962421} # lost: 2
limits['WS_cis/AC/min_dist/99.99'] = {'max': 2.8549822829340976, 'min': 1.2151564323117876} # lost: 0
limits['WS_cis/AC/n2_z/100.00'] = {'max': -0.4449532, 'min': -0.99957335} # lost: 0
limits['WS_cis/AC/n2_z/95.00'] = {'max': -0.66896671, 'min': -0.99957335} # lost: 103
limits['WS_cis/AC/n2_z/99.00'] = {'max': -0.61613488, 'min': -0.99957335} # lost: 20
limits['WS_cis/AC/n2_z/99.50'] = {'max': -0.5874843, 'min': -0.99957335} # lost: 10
limits['WS_cis/AC/n2_z/99.90'] = {'max': -0.52695239, 'min': -0.99957335} # lost: 2
limits['WS_cis/AC/n2_z/99.99'] = {'max': -0.4449532, 'min': -0.99957335} # lost: 0
limits['WS_cis/AC/nn_ang_norm/100.00'] = {'max': 64.50792151290419, 'min': 2.6241263494058842} # lost: 0
limits['WS_cis/AC/nn_ang_norm/95.00'] = {'max': 47.769545744169136, 'min': 2.6241263494058842} # lost: 103
limits['WS_cis/AC/nn_ang_norm/99.00'] = {'max': 51.985179481036027, 'min': 2.6241263494058842} # lost: 20
limits['WS_cis/AC/nn_ang_norm/99.50'] = {'max': 53.702562245944023, 'min': 2.6241263494058842} # lost: 10
limits['WS_cis/AC/nn_ang_norm/99.90'] = {'max': 58.125847393957642, 'min': 2.6241263494058842} # lost: 2
limits['WS_cis/AC/nn_ang_norm/99.99'] = {'max': 64.50792151290419, 'min': 2.6241263494058842} # lost: 0
limits['WS_cis/AC/rot_ang/100.00'] = {'max': 71.835721154875415, 'min': -57.834821599327078} # lost: 0
limits['WS_cis/AC/rot_ang/95.00'] = {'max': 52.418345868365158, 'min': 18.198734076357866} # lost: 103
limits['WS_cis/AC/rot_ang/99.00'] = {'max': 57.921020905340754, 'min': -28.691598225434532} # lost: 20
limits['WS_cis/AC/rot_ang/99.50'] = {'max': 63.548896386553146, 'min': -42.041803185768288} # lost: 10
limits['WS_cis/AC/rot_ang/99.90'] = {'max': 68.937197383354274, 'min': -56.566193795769443} # lost: 2
limits['WS_cis/AC/rot_ang/99.99'] = {'max': 71.835721154875415, 'min': -57.834821599327078} # lost: 0
limits['WS_cis/AG/dist/100.00'] = {'max': 7.4417061192036495, 'min': 5.1457438504154585} # lost: 0
limits['WS_cis/AG/dist/95.00'] = {'max': 6.9509609592783006, 'min': 5.5073869330281155} # lost: 47
limits['WS_cis/AG/dist/99.00'] = {'max': 7.2750173456155878, 'min': 5.3831965356664551} # lost: 9
limits['WS_cis/AG/dist/99.50'] = {'max': 7.3158081780381918, 'min': 5.3267885075455297} # lost: 4
limits['WS_cis/AG/dist/99.90'] = {'max': 7.4417061192036495, 'min': 5.1457438504154585} # lost: 0
limits['WS_cis/AG/dist/99.99'] = {'max': 7.4417061192036495, 'min': 5.1457438504154585} # lost: 0
limits['WS_cis/AG/min_dist/100.00'] = {'max': 2.5519686963304946, 'min': 0.81775359744797071} # lost: 0
limits['WS_cis/AG/min_dist/95.00'] = {'max': 2.4279864454712601, 'min': 1.4165659062960545} # lost: 47
limits['WS_cis/AG/min_dist/99.00'] = {'max': 2.5129122952143517, 'min': 1.0584211928308296} # lost: 9
limits['WS_cis/AG/min_dist/99.50'] = {'max': 2.5427567265998618, 'min': 1.0200125011765868} # lost: 4
limits['WS_cis/AG/min_dist/99.90'] = {'max': 2.5519686963304946, 'min': 0.81775359744797071} # lost: 0
limits['WS_cis/AG/min_dist/99.99'] = {'max': 2.5519686963304946, 'min': 0.81775359744797071} # lost: 0
limits['WS_cis/AG/n2_z/100.00'] = {'max': -0.42700094, 'min': -0.99991137} # lost: 0
limits['WS_cis/AG/n2_z/95.00'] = {'max': -0.49270356, 'min': -0.99991137} # lost: 47
limits['WS_cis/AG/n2_z/99.00'] = {'max': -0.44119462, 'min': -0.99991137} # lost: 9
limits['WS_cis/AG/n2_z/99.50'] = {'max': -0.43180957, 'min': -0.99991137} # lost: 4
limits['WS_cis/AG/n2_z/99.90'] = {'max': -0.42700094, 'min': -0.99991137} # lost: 0
limits['WS_cis/AG/n2_z/99.99'] = {'max': -0.42700094, 'min': -0.99991137} # lost: 0
limits['WS_cis/AG/nn_ang_norm/100.00'] = {'max': 64.840893234942314, 'min': 0.60035495870945965} # lost: 0
limits['WS_cis/AG/nn_ang_norm/95.00'] = {'max': 60.808445171615162, 'min': 0.60035495870945965} # lost: 47
limits['WS_cis/AG/nn_ang_norm/99.00'] = {'max': 63.896701544458097, 'min': 0.60035495870945965} # lost: 9
limits['WS_cis/AG/nn_ang_norm/99.50'] = {'max': 64.626876087489137, 'min': 0.60035495870945965} # lost: 4
limits['WS_cis/AG/nn_ang_norm/99.90'] = {'max': 64.840893234942314, 'min': 0.60035495870945965} # lost: 0
limits['WS_cis/AG/nn_ang_norm/99.99'] = {'max': 64.840893234942314, 'min': 0.60035495870945965} # lost: 0
limits['WS_cis/AG/rot_ang/100.00'] = {'max': 60.300978611678197, 'min': -85.243668408411537} # lost: 0
limits['WS_cis/AG/rot_ang/95.00'] = {'max': 56.444941815542457, 'min': -80.10933978244816} # lost: 47
limits['WS_cis/AG/rot_ang/99.00'] = {'max': 58.23830781261583, 'min': -82.672465696914855} # lost: 9
limits['WS_cis/AG/rot_ang/99.50'] = {'max': 59.367917237200686, 'min': -83.964691158067993} # lost: 4
limits['WS_cis/AG/rot_ang/99.90'] = {'max': 60.300978611678197, 'min': -85.243668408411537} # lost: 0
limits['WS_cis/AG/rot_ang/99.99'] = {'max': 60.300978611678197, 'min': -85.243668408411537} # lost: 0
limits['WS_cis/AU/dist/100.00'] = {'max': 8.0744492328050725, 'min': 6.1877693990454459} # lost: 0
limits['WS_cis/AU/dist/95.00'] = {'max': 7.9019237034845942, 'min': 6.6237073698129629} # lost: 37
limits['WS_cis/AU/dist/99.00'] = {'max': 8.0192582386311884, 'min': 6.3883696485230077} # lost: 7
limits['WS_cis/AU/dist/99.50'] = {'max': 8.0370934551417683, 'min': 6.3528703843683614} # lost: 3
limits['WS_cis/AU/dist/99.90'] = {'max': 8.0744492328050725, 'min': 6.1877693990454459} # lost: 0
limits['WS_cis/AU/dist/99.99'] = {'max': 8.0744492328050725, 'min': 6.1877693990454459} # lost: 0
limits['WS_cis/AU/min_dist/100.00'] = {'max': 2.6901837091385969, 'min': 1.264434797928877} # lost: 0
limits['WS_cis/AU/min_dist/95.00'] = {'max': 2.4827266110697113, 'min': 1.5669485848922042} # lost: 37
limits['WS_cis/AU/min_dist/99.00'] = {'max': 2.5868280794901106, 'min': 1.5004347723677804} # lost: 7
limits['WS_cis/AU/min_dist/99.50'] = {'max': 2.6345955021225325, 'min': 1.3215300187209462} # lost: 3
limits['WS_cis/AU/min_dist/99.90'] = {'max': 2.6901837091385969, 'min': 1.264434797928877} # lost: 0
limits['WS_cis/AU/min_dist/99.99'] = {'max': 2.6901837091385969, 'min': 1.264434797928877} # lost: 0
limits['WS_cis/AU/n2_z/100.00'] = {'max': -0.42901492, 'min': -0.9993279} # lost: 0
limits['WS_cis/AU/n2_z/95.00'] = {'max': -0.64688975, 'min': -0.9993279} # lost: 37
limits['WS_cis/AU/n2_z/99.00'] = {'max': -0.60051787, 'min': -0.9993279} # lost: 7
limits['WS_cis/AU/n2_z/99.50'] = {'max': -0.51592368, 'min': -0.9993279} # lost: 3
limits['WS_cis/AU/n2_z/99.90'] = {'max': -0.42901492, 'min': -0.9993279} # lost: 0
limits['WS_cis/AU/n2_z/99.99'] = {'max': -0.42901492, 'min': -0.9993279} # lost: 0
limits['WS_cis/AU/nn_ang_norm/100.00'] = {'max': 64.817943799331076, 'min': 2.4823043014797292} # lost: 0
limits['WS_cis/AU/nn_ang_norm/95.00'] = {'max': 50.052727719542645, 'min': 2.4823043014797292} # lost: 37
limits['WS_cis/AU/nn_ang_norm/99.00'] = {'max': 55.396080329892001, 'min': 2.4823043014797292} # lost: 7
limits['WS_cis/AU/nn_ang_norm/99.50'] = {'max': 58.982380436633917, 'min': 2.4823043014797292} # lost: 3
limits['WS_cis/AU/nn_ang_norm/99.90'] = {'max': 64.817943799331076, 'min': 2.4823043014797292} # lost: 0
limits['WS_cis/AU/nn_ang_norm/99.99'] = {'max': 64.817943799331076, 'min': 2.4823043014797292} # lost: 0
limits['WS_cis/AU/rot_ang/100.00'] = {'max': 76.66419499098842, 'min': -66.406237988413523} # lost: 0
limits['WS_cis/AU/rot_ang/95.00'] = {'max': 57.965172759699811, 'min': 15.688936330490804} # lost: 37
limits['WS_cis/AU/rot_ang/99.00'] = {'max': 62.847182636260712, 'min': -47.097212406152501} # lost: 7
limits['WS_cis/AU/rot_ang/99.50'] = {'max': 66.731150287281238, 'min': -52.529855541130509} # lost: 3
limits['WS_cis/AU/rot_ang/99.90'] = {'max': 76.66419499098842, 'min': -66.406237988413523} # lost: 0
limits['WS_cis/AU/rot_ang/99.99'] = {'max': 76.66419499098842, 'min': -66.406237988413523} # lost: 0
limits['WS_cis/CA/dist/100.00'] = {'max': 7.3304593213565159, 'min': 5.8829997943081693} # lost: 0
limits['WS_cis/CA/dist/95.00'] = {'max': 7.1192200388800346, 'min': 6.4077709153851492} # lost: 32
limits['WS_cis/CA/dist/99.00'] = {'max': 7.2969193794531186, 'min': 6.271886276047792} # lost: 6
limits['WS_cis/CA/dist/99.50'] = {'max': 7.3152688821318783, 'min': 5.8953640200944877} # lost: 3
limits['WS_cis/CA/dist/99.90'] = {'max': 7.3304593213565159, 'min': 5.8829997943081693} # lost: 0
limits['WS_cis/CA/dist/99.99'] = {'max': 7.3304593213565159, 'min': 5.8829997943081693} # lost: 0
limits['WS_cis/CA/min_dist/100.00'] = {'max': 2.7779139597281737, 'min': 1.7633500843699255} # lost: 0
limits['WS_cis/CA/min_dist/95.00'] = {'max': 2.5666996502033848, 'min': 1.9054105668310526} # lost: 32
limits['WS_cis/CA/min_dist/99.00'] = {'max': 2.7051527228943737, 'min': 1.8310531913130093} # lost: 6
limits['WS_cis/CA/min_dist/99.50'] = {'max': 2.7130386799069748, 'min': 1.7836800943905118} # lost: 3
limits['WS_cis/CA/min_dist/99.90'] = {'max': 2.7779139597281737, 'min': 1.7633500843699255} # lost: 0
limits['WS_cis/CA/min_dist/99.99'] = {'max': 2.7779139597281737, 'min': 1.7633500843699255} # lost: 0
limits['WS_cis/CA/n2_z/100.00'] = {'max': -0.43140623, 'min': -0.99944931} # lost: 0
limits['WS_cis/CA/n2_z/95.00'] = {'max': -0.63770378, 'min': -0.99944931} # lost: 32
limits['WS_cis/CA/n2_z/99.00'] = {'max': -0.48563746, 'min': -0.99944931} # lost: 6
limits['WS_cis/CA/n2_z/99.50'] = {'max': -0.4758139, 'min': -0.99944931} # lost: 3
limits['WS_cis/CA/n2_z/99.90'] = {'max': -0.43140623, 'min': -0.99944931} # lost: 0
limits['WS_cis/CA/n2_z/99.99'] = {'max': -0.43140623, 'min': -0.99944931} # lost: 0
limits['WS_cis/CA/nn_ang_norm/100.00'] = {'max': 64.525898570799669, 'min': 1.9910497756157497} # lost: 0
limits['WS_cis/CA/nn_ang_norm/95.00'] = {'max': 50.289393774283582, 'min': 1.9910497756157497} # lost: 32
limits['WS_cis/CA/nn_ang_norm/99.00'] = {'max': 61.282009507528826, 'min': 1.9910497756157497} # lost: 6
limits['WS_cis/CA/nn_ang_norm/99.50'] = {'max': 61.868695436476244, 'min': 1.9910497756157497} # lost: 3
limits['WS_cis/CA/nn_ang_norm/99.90'] = {'max': 64.525898570799669, 'min': 1.9910497756157497} # lost: 0
limits['WS_cis/CA/nn_ang_norm/99.99'] = {'max': 64.525898570799669, 'min': 1.9910497756157497} # lost: 0
limits['WS_cis/CA/rot_ang/100.00'] = {'max': 64.491657721469608, 'min': -62.794953370458117} # lost: 0
limits['WS_cis/CA/rot_ang/95.00'] = {'max': 51.54436879386796, 'min': -50.529338180883727} # lost: 32
limits['WS_cis/CA/rot_ang/99.00'] = {'max': 61.399590569938674, 'min': -59.35182373466764} # lost: 6
limits['WS_cis/CA/rot_ang/99.50'] = {'max': 61.715868577071099, 'min': -61.800740638450115} # lost: 3
limits['WS_cis/CA/rot_ang/99.90'] = {'max': 64.491657721469608, 'min': -62.794953370458117} # lost: 0
limits['WS_cis/CA/rot_ang/99.99'] = {'max': 64.491657721469608, 'min': -62.794953370458117} # lost: 0
limits['WS_cis/CC/dist/100.00'] = {'max': 7.9979517391589772, 'min': 6.1214010002377064} # lost: 0
limits['WS_cis/CC/dist/95.00'] = {'max': 7.7654422146638939, 'min': 6.8891440671523068} # lost: 37
limits['WS_cis/CC/dist/99.00'] = {'max': 7.8541859567789398, 'min': 6.6590340711254887} # lost: 7
limits['WS_cis/CC/dist/99.50'] = {'max': 7.8937072330897529, 'min': 6.3191579929995738} # lost: 3
limits['WS_cis/CC/dist/99.90'] = {'max': 7.9979517391589772, 'min': 6.1214010002377064} # lost: 0
limits['WS_cis/CC/dist/99.99'] = {'max': 7.9979517391589772, 'min': 6.1214010002377064} # lost: 0
limits['WS_cis/CC/min_dist/100.00'] = {'max': 2.5777615636437132, 'min': 1.3118482300577794} # lost: 0
limits['WS_cis/CC/min_dist/95.00'] = {'max': 2.3858260657726462, 'min': 1.5680076461009782} # lost: 37
limits['WS_cis/CC/min_dist/99.00'] = {'max': 2.4968204019848357, 'min': 1.4420794853541379} # lost: 7
limits['WS_cis/CC/min_dist/99.50'] = {'max': 2.5521981874195334, 'min': 1.3470895321659306} # lost: 3
limits['WS_cis/CC/min_dist/99.90'] = {'max': 2.5777615636437132, 'min': 1.3118482300577794} # lost: 0
limits['WS_cis/CC/min_dist/99.99'] = {'max': 2.5777615636437132, 'min': 1.3118482300577794} # lost: 0
limits['WS_cis/CC/n2_z/100.00'] = {'max': -0.44466737, 'min': -0.99465472} # lost: 0
limits['WS_cis/CC/n2_z/95.00'] = {'max': -0.54137689, 'min': -0.99465472} # lost: 37
limits['WS_cis/CC/n2_z/99.00'] = {'max': -0.4667623, 'min': -0.99465472} # lost: 7
limits['WS_cis/CC/n2_z/99.50'] = {'max': -0.45653915, 'min': -0.99465472} # lost: 3
limits['WS_cis/CC/n2_z/99.90'] = {'max': -0.44466737, 'min': -0.99465472} # lost: 0
limits['WS_cis/CC/n2_z/99.99'] = {'max': -0.44466737, 'min': -0.99465472} # lost: 0
limits['WS_cis/CC/nn_ang_norm/100.00'] = {'max': 63.672739641573372, 'min': 11.760009798296522} # lost: 0
limits['WS_cis/CC/nn_ang_norm/95.00'] = {'max': 57.27938205011796, 'min': 11.760009798296522} # lost: 37
limits['WS_cis/CC/nn_ang_norm/99.00'] = {'max': 62.299256901375514, 'min': 11.760009798296522} # lost: 7
limits['WS_cis/CC/nn_ang_norm/99.50'] = {'max': 62.958752646875254, 'min': 11.760009798296522} # lost: 3
limits['WS_cis/CC/nn_ang_norm/99.90'] = {'max': 63.672739641573372, 'min': 11.760009798296522} # lost: 0
limits['WS_cis/CC/nn_ang_norm/99.99'] = {'max': 63.672739641573372, 'min': 11.760009798296522} # lost: 0
limits['WS_cis/CC/rot_ang/100.00'] = {'max': 63.598389002161994, 'min': -63.761090978915703} # lost: 0
limits['WS_cis/CC/rot_ang/95.00'] = {'max': 58.075407374948369, 'min': -56.783151765859216} # lost: 37
limits['WS_cis/CC/rot_ang/99.00'] = {'max': 62.320412602551954, 'min': -62.364292760376706} # lost: 7
limits['WS_cis/CC/rot_ang/99.50'] = {'max': 63.038223941574394, 'min': -63.115741024895485} # lost: 3
limits['WS_cis/CC/rot_ang/99.90'] = {'max': 63.598389002161994, 'min': -63.761090978915703} # lost: 0
limits['WS_cis/CC/rot_ang/99.99'] = {'max': 63.598389002161994, 'min': -63.761090978915703} # lost: 0
limits['WS_cis/CG/dist/100.00'] = {'max': 7.3152364839789499, 'min': 5.9824775167726134} # lost: 0
limits['WS_cis/CG/dist/95.00'] = {'max': 7.1981421000817418, 'min': 6.1527476520445896} # lost: 11
limits['WS_cis/CG/dist/99.00'] = {'max': 7.2713645315353537, 'min': 6.0505312748880842} # lost: 2
limits['WS_cis/CG/dist/99.50'] = {'max': 7.2713645315353537, 'min': 5.9824775167726134} # lost: 1
limits['WS_cis/CG/dist/99.90'] = {'max': 7.3152364839789499, 'min': 5.9824775167726134} # lost: 0
limits['WS_cis/CG/dist/99.99'] = {'max': 7.3152364839789499, 'min': 5.9824775167726134} # lost: 0
limits['WS_cis/CG/min_dist/100.00'] = {'max': 2.4888895751019424, 'min': 1.0135887116013091} # lost: 0
limits['WS_cis/CG/min_dist/95.00'] = {'max': 2.405224941751793, 'min': 1.4434488859031724} # lost: 11
limits['WS_cis/CG/min_dist/99.00'] = {'max': 2.4647034794600535, 'min': 1.2609851996841988} # lost: 2
limits['WS_cis/CG/min_dist/99.50'] = {'max': 2.4647034794600535, 'min': 1.0135887116013091} # lost: 1
limits['WS_cis/CG/min_dist/99.90'] = {'max': 2.4888895751019424, 'min': 1.0135887116013091} # lost: 0
limits['WS_cis/CG/min_dist/99.99'] = {'max': 2.4888895751019424, 'min': 1.0135887116013091} # lost: 0
limits['WS_cis/CG/n2_z/100.00'] = {'max': -0.46673396, 'min': -0.99324632} # lost: 0
limits['WS_cis/CG/n2_z/95.00'] = {'max': -0.56513971, 'min': -0.99324632} # lost: 11
limits['WS_cis/CG/n2_z/99.00'] = {'max': -0.47279298, 'min': -0.99324632} # lost: 2
limits['WS_cis/CG/n2_z/99.50'] = {'max': -0.47095317, 'min': -0.99324632} # lost: 1
limits['WS_cis/CG/n2_z/99.90'] = {'max': -0.46673396, 'min': -0.99324632} # lost: 0
limits['WS_cis/CG/n2_z/99.99'] = {'max': -0.46673396, 'min': -0.99324632} # lost: 0
limits['WS_cis/CG/nn_ang_norm/100.00'] = {'max': 62.211038178055631, 'min': 6.7891757052796606} # lost: 0
limits['WS_cis/CG/nn_ang_norm/95.00'] = {'max': 55.86513674095346, 'min': 6.7891757052796606} # lost: 11
limits['WS_cis/CG/nn_ang_norm/99.00'] = {'max': 62.116549341077672, 'min': 6.7891757052796606} # lost: 2
limits['WS_cis/CG/nn_ang_norm/99.50'] = {'max': 62.168062627797909, 'min': 6.7891757052796606} # lost: 1
limits['WS_cis/CG/nn_ang_norm/99.90'] = {'max': 62.211038178055631, 'min': 6.7891757052796606} # lost: 0
limits['WS_cis/CG/nn_ang_norm/99.99'] = {'max': 62.211038178055631, 'min': 6.7891757052796606} # lost: 0
limits['WS_cis/CG/rot_ang/100.00'] = {'max': 62.195025540245467, 'min': -67.799708073611711} # lost: 0
limits['WS_cis/CG/rot_ang/95.00'] = {'max': 56.921428190845305, 'min': -62.170295459248379} # lost: 11
limits['WS_cis/CG/rot_ang/99.00'] = {'max': 62.178405471965618, 'min': -65.452272416716028} # lost: 2
limits['WS_cis/CG/rot_ang/99.50'] = {'max': 62.178405471965618, 'min': -67.799708073611711} # lost: 1
limits['WS_cis/CG/rot_ang/99.90'] = {'max': 62.195025540245467, 'min': -67.799708073611711} # lost: 0
limits['WS_cis/CG/rot_ang/99.99'] = {'max': 62.195025540245467, 'min': -67.799708073611711} # lost: 0
limits['WS_cis/CU/dist/100.00'] = {'max': 8.1096766331055044, 'min': 6.7276160736303963} # lost: 0
limits['WS_cis/CU/dist/95.00'] = {'max': 7.8412828597955144, 'min': 6.938823778174485} # lost: 12
limits['WS_cis/CU/dist/99.00'] = {'max': 7.9667725491751034, 'min': 6.8128860032124408} # lost: 2
limits['WS_cis/CU/dist/99.50'] = {'max': 7.9667725491751034, 'min': 6.7276160736303963} # lost: 1
limits['WS_cis/CU/dist/99.90'] = {'max': 8.1096766331055044, 'min': 6.7276160736303963} # lost: 0
limits['WS_cis/CU/dist/99.99'] = {'max': 8.1096766331055044, 'min': 6.7276160736303963} # lost: 0
limits['WS_cis/CU/min_dist/100.00'] = {'max': 2.6720930353149073, 'min': 1.5414978872178382} # lost: 0
limits['WS_cis/CU/min_dist/95.00'] = {'max': 2.5430996802998971, 'min': 1.5956514261386789} # lost: 12
limits['WS_cis/CU/min_dist/99.00'] = {'max': 2.6472694899956442, 'min': 1.5459467099384077} # lost: 2
limits['WS_cis/CU/min_dist/99.50'] = {'max': 2.6472694899956442, 'min': 1.5414978872178382} # lost: 1
limits['WS_cis/CU/min_dist/99.90'] = {'max': 2.6720930353149073, 'min': 1.5414978872178382} # lost: 0
limits['WS_cis/CU/min_dist/99.99'] = {'max': 2.6720930353149073, 'min': 1.5414978872178382} # lost: 0
limits['WS_cis/CU/n2_z/100.00'] = {'max': -0.48048148, 'min': -0.9964456} # lost: 0
limits['WS_cis/CU/n2_z/95.00'] = {'max': -0.71064287, 'min': -0.9964456} # lost: 12
limits['WS_cis/CU/n2_z/99.00'] = {'max': -0.53614289, 'min': -0.9964456} # lost: 2
limits['WS_cis/CU/n2_z/99.50'] = {'max': -0.49618039, 'min': -0.9964456} # lost: 1
limits['WS_cis/CU/n2_z/99.90'] = {'max': -0.48048148, 'min': -0.9964456} # lost: 0
limits['WS_cis/CU/n2_z/99.99'] = {'max': -0.48048148, 'min': -0.9964456} # lost: 0
limits['WS_cis/CU/nn_ang_norm/100.00'] = {'max': 60.517561075242668, 'min': 4.5331915431811183} # lost: 0
limits['WS_cis/CU/nn_ang_norm/95.00'] = {'max': 44.459977581839439, 'min': 4.5331915431811183} # lost: 12
limits['WS_cis/CU/nn_ang_norm/99.00'] = {'max': 59.123382861859668, 'min': 4.5331915431811183} # lost: 2
limits['WS_cis/CU/nn_ang_norm/99.50'] = {'max': 59.834023063864464, 'min': 4.5331915431811183} # lost: 1
limits['WS_cis/CU/nn_ang_norm/99.90'] = {'max': 60.517561075242668, 'min': 4.5331915431811183} # lost: 0
limits['WS_cis/CU/nn_ang_norm/99.99'] = {'max': 60.517561075242668, 'min': 4.5331915431811183} # lost: 0
limits['WS_cis/CU/rot_ang/100.00'] = {'max': 50.984405499660767, 'min': -62.157531935805721} # lost: 0
limits['WS_cis/CU/rot_ang/95.00'] = {'max': 45.774549439192583, 'min': -42.002497139098168} # lost: 12
limits['WS_cis/CU/rot_ang/99.00'] = {'max': 50.532318602584475, 'min': -61.364851989182029} # lost: 2
limits['WS_cis/CU/rot_ang/99.50'] = {'max': 50.532318602584475, 'min': -62.157531935805721} # lost: 1
limits['WS_cis/CU/rot_ang/99.90'] = {'max': 50.984405499660767, 'min': -62.157531935805721} # lost: 0
limits['WS_cis/CU/rot_ang/99.99'] = {'max': 50.984405499660767, 'min': -62.157531935805721} # lost: 0
limits['WS_cis/GA/dist/100.00'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['WS_cis/GA/dist/95.00'] = {'max': 6.1097414547671862, 'min': 5.0681236259283864} # lost: 5
limits['WS_cis/GA/dist/99.00'] = {'max': 6.2759909865586465, 'min': 4.9404726868995228} # lost: 1
limits['WS_cis/GA/dist/99.50'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['WS_cis/GA/dist/99.90'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['WS_cis/GA/dist/99.99'] = {'max': 6.373402758141137, 'min': 4.9404726868995228} # lost: 0
limits['WS_cis/GA/min_dist/100.00'] = {'max': 2.5367635673503379, 'min': 0.70248235068022269} # lost: 0
limits['WS_cis/GA/min_dist/95.00'] = {'max': 2.4282349554380023, 'min': 1.1911168794544493} # lost: 5
limits['WS_cis/GA/min_dist/99.00'] = {'max': 2.5009236140351194, 'min': 0.70248235068022269} # lost: 1
limits['WS_cis/GA/min_dist/99.50'] = {'max': 2.5367635673503379, 'min': 0.70248235068022269} # lost: 0
limits['WS_cis/GA/min_dist/99.90'] = {'max': 2.5367635673503379, 'min': 0.70248235068022269} # lost: 0
limits['WS_cis/GA/min_dist/99.99'] = {'max': 2.5367635673503379, 'min': 0.70248235068022269} # lost: 0
limits['WS_cis/GA/n2_z/100.00'] = {'max': -0.43636438, 'min': -0.97197884} # lost: 0
limits['WS_cis/GA/n2_z/95.00'] = {'max': -0.5092153, 'min': -0.97197884} # lost: 5
limits['WS_cis/GA/n2_z/99.00'] = {'max': -0.49162388, 'min': -0.97197884} # lost: 1
limits['WS_cis/GA/n2_z/99.50'] = {'max': -0.43636438, 'min': -0.97197884} # lost: 0
limits['WS_cis/GA/n2_z/99.90'] = {'max': -0.43636438, 'min': -0.97197884} # lost: 0
limits['WS_cis/GA/n2_z/99.99'] = {'max': -0.43636438, 'min': -0.97197884} # lost: 0
limits['WS_cis/GA/nn_ang_norm/100.00'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['WS_cis/GA/nn_ang_norm/95.00'] = {'max': 58.994893343193382, 'min': 13.532730755859973} # lost: 5
limits['WS_cis/GA/nn_ang_norm/99.00'] = {'max': 60.39450838715571, 'min': 13.532730755859973} # lost: 1
limits['WS_cis/GA/nn_ang_norm/99.50'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['WS_cis/GA/nn_ang_norm/99.90'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['WS_cis/GA/nn_ang_norm/99.99'] = {'max': 62.36001826423194, 'min': 13.532730755859973} # lost: 0
limits['WS_cis/GA/rot_ang/100.00'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['WS_cis/GA/rot_ang/95.00'] = {'max': 54.540552381035567, 'min': -67.834571085319595} # lost: 5
limits['WS_cis/GA/rot_ang/99.00'] = {'max': 55.140029611418463, 'min': -69.515159579358496} # lost: 1
limits['WS_cis/GA/rot_ang/99.50'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['WS_cis/GA/rot_ang/99.90'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['WS_cis/GA/rot_ang/99.99'] = {'max': 62.872526392760292, 'min': -69.515159579358496} # lost: 0
limits['WS_cis/GC/dist/100.00'] = {'max': 7.202403511159214, 'min': 5.7623016963608471} # lost: 0
limits['WS_cis/GC/dist/95.00'] = {'max': 6.9828070521518155, 'min': 5.9216044548680671} # lost: 13
limits['WS_cis/GC/dist/99.00'] = {'max': 7.1221959556895573, 'min': 5.7947999333995046} # lost: 2
limits['WS_cis/GC/dist/99.50'] = {'max': 7.1221959556895573, 'min': 5.7623016963608471} # lost: 1
limits['WS_cis/GC/dist/99.90'] = {'max': 7.202403511159214, 'min': 5.7623016963608471} # lost: 0
limits['WS_cis/GC/dist/99.99'] = {'max': 7.202403511159214, 'min': 5.7623016963608471} # lost: 0
limits['WS_cis/GC/min_dist/100.00'] = {'max': 2.4250220893616676, 'min': 1.3382589183530951} # lost: 0
limits['WS_cis/GC/min_dist/95.00'] = {'max': 2.2748196767277773, 'min': 1.5183127427055629} # lost: 13
limits['WS_cis/GC/min_dist/99.00'] = {'max': 2.3891613447021887, 'min': 1.4484542010438137} # lost: 2
limits['WS_cis/GC/min_dist/99.50'] = {'max': 2.3891613447021887, 'min': 1.3382589183530951} # lost: 1
limits['WS_cis/GC/min_dist/99.90'] = {'max': 2.4250220893616676, 'min': 1.3382589183530951} # lost: 0
limits['WS_cis/GC/min_dist/99.99'] = {'max': 2.4250220893616676, 'min': 1.3382589183530951} # lost: 0
limits['WS_cis/GC/n2_z/100.00'] = {'max': -0.46228236, 'min': -0.99344271} # lost: 0
limits['WS_cis/GC/n2_z/95.00'] = {'max': -0.77582854, 'min': -0.99344271} # lost: 13
limits['WS_cis/GC/n2_z/99.00'] = {'max': -0.46256113, 'min': -0.99344271} # lost: 2
limits['WS_cis/GC/n2_z/99.50'] = {'max': -0.46256113, 'min': -0.99344271} # lost: 1
limits['WS_cis/GC/n2_z/99.90'] = {'max': -0.46228236, 'min': -0.99344271} # lost: 0
limits['WS_cis/GC/n2_z/99.99'] = {'max': -0.46228236, 'min': -0.99344271} # lost: 0
limits['WS_cis/GC/nn_ang_norm/100.00'] = {'max': 62.555061146170829, 'min': 6.0955836554431926} # lost: 0
limits['WS_cis/GC/nn_ang_norm/95.00'] = {'max': 39.158739917912385, 'min': 6.0955836554431926} # lost: 13
limits['WS_cis/GC/nn_ang_norm/99.00'] = {'max': 62.5045040859344, 'min': 6.0955836554431926} # lost: 2
limits['WS_cis/GC/nn_ang_norm/99.50'] = {'max': 62.5045040859344, 'min': 6.0955836554431926} # lost: 1
limits['WS_cis/GC/nn_ang_norm/99.90'] = {'max': 62.555061146170829, 'min': 6.0955836554431926} # lost: 0
limits['WS_cis/GC/nn_ang_norm/99.99'] = {'max': 62.555061146170829, 'min': 6.0955836554431926} # lost: 0
limits['WS_cis/GC/rot_ang/100.00'] = {'max': 54.071337425454885, 'min': -66.74993170020403} # lost: 0
limits['WS_cis/GC/rot_ang/95.00'] = {'max': 42.434999222811697, 'min': -38.850154216277588} # lost: 13
limits['WS_cis/GC/rot_ang/99.00'] = {'max': 50.102170499891294, 'min': -66.734381066495843} # lost: 2
limits['WS_cis/GC/rot_ang/99.50'] = {'max': 50.102170499891294, 'min': -66.74993170020403} # lost: 1
limits['WS_cis/GC/rot_ang/99.90'] = {'max': 54.071337425454885, 'min': -66.74993170020403} # lost: 0
limits['WS_cis/GC/rot_ang/99.99'] = {'max': 54.071337425454885, 'min': -66.74993170020403} # lost: 0
limits['WS_cis/GG/dist/100.00'] = {'max': 7.3776015269020121, 'min': 4.8782614611193313} # lost: 0
limits['WS_cis/GG/dist/95.00'] = {'max': 7.3205115253157915, 'min': 5.091811240414275} # lost: 10
limits['WS_cis/GG/dist/99.00'] = {'max': 7.3396624430038306, 'min': 4.9557988554557824} # lost: 2
limits['WS_cis/GG/dist/99.50'] = {'max': 7.3396624430038306, 'min': 4.8782614611193313} # lost: 1
limits['WS_cis/GG/dist/99.90'] = {'max': 7.3776015269020121, 'min': 4.8782614611193313} # lost: 0
limits['WS_cis/GG/dist/99.99'] = {'max': 7.3776015269020121, 'min': 4.8782614611193313} # lost: 0
limits['WS_cis/GG/min_dist/100.00'] = {'max': 2.4463055624818537, 'min': 0.49811434281119793} # lost: 0
limits['WS_cis/GG/min_dist/95.00'] = {'max': 2.2992949354606216, 'min': 1.279974190250688} # lost: 10
limits['WS_cis/GG/min_dist/99.00'] = {'max': 2.3530956661634885, 'min': 0.72395809574157566} # lost: 2
limits['WS_cis/GG/min_dist/99.50'] = {'max': 2.3530956661634885, 'min': 0.49811434281119793} # lost: 1
limits['WS_cis/GG/min_dist/99.90'] = {'max': 2.4463055624818537, 'min': 0.49811434281119793} # lost: 0
limits['WS_cis/GG/min_dist/99.99'] = {'max': 2.4463055624818537, 'min': 0.49811434281119793} # lost: 0
limits['WS_cis/GG/n2_z/100.00'] = {'max': -0.4234755, 'min': -0.99894094} # lost: 0
limits['WS_cis/GG/n2_z/95.00'] = {'max': -0.64240038, 'min': -0.99894094} # lost: 10
limits['WS_cis/GG/n2_z/99.00'] = {'max': -0.44912422, 'min': -0.99894094} # lost: 2
limits['WS_cis/GG/n2_z/99.50'] = {'max': -0.43901023, 'min': -0.99894094} # lost: 1
limits['WS_cis/GG/n2_z/99.90'] = {'max': -0.4234755, 'min': -0.99894094} # lost: 0
limits['WS_cis/GG/n2_z/99.99'] = {'max': -0.4234755, 'min': -0.99894094} # lost: 0
limits['WS_cis/GG/nn_ang_norm/100.00'] = {'max': 64.88982471015629, 'min': 2.6029391026005158} # lost: 0
limits['WS_cis/GG/nn_ang_norm/95.00'] = {'max': 50.101713836269965, 'min': 2.6029391026005158} # lost: 10
limits['WS_cis/GG/nn_ang_norm/99.00'] = {'max': 62.45756702595807, 'min': 2.6029391026005158} # lost: 2
limits['WS_cis/GG/nn_ang_norm/99.50'] = {'max': 63.998512344226299, 'min': 2.6029391026005158} # lost: 1
limits['WS_cis/GG/nn_ang_norm/99.90'] = {'max': 64.88982471015629, 'min': 2.6029391026005158} # lost: 0
limits['WS_cis/GG/nn_ang_norm/99.99'] = {'max': 64.88982471015629, 'min': 2.6029391026005158} # lost: 0
limits['WS_cis/GG/rot_ang/100.00'] = {'max': 65.109359526728085, 'min': -65.108987016171014} # lost: 0
limits['WS_cis/GG/rot_ang/95.00'] = {'max': 50.857558907105719, 'min': -53.035222238755779} # lost: 10
limits['WS_cis/GG/rot_ang/99.00'] = {'max': 63.959269742958973, 'min': -62.845890676480181} # lost: 2
limits['WS_cis/GG/rot_ang/99.50'] = {'max': 63.959269742958973, 'min': -65.108987016171014} # lost: 1
limits['WS_cis/GG/rot_ang/99.90'] = {'max': 65.109359526728085, 'min': -65.108987016171014} # lost: 0
limits['WS_cis/GG/rot_ang/99.99'] = {'max': 65.109359526728085, 'min': -65.108987016171014} # lost: 0
limits['WS_cis/GU/dist/100.00'] = {'max': 7.3726289268682672, 'min': 5.2197275360409305} # lost: 0
limits['WS_cis/GU/dist/95.00'] = {'max': 7.0362203245488679, 'min': 6.0267426039710958} # lost: 21
limits['WS_cis/GU/dist/99.00'] = {'max': 7.1680617185046911, 'min': 5.9410914308316691} # lost: 4
limits['WS_cis/GU/dist/99.50'] = {'max': 7.1681064724676515, 'min': 5.9337052259880867} # lost: 2
limits['WS_cis/GU/dist/99.90'] = {'max': 7.3726289268682672, 'min': 5.2197275360409305} # lost: 0
limits['WS_cis/GU/dist/99.99'] = {'max': 7.3726289268682672, 'min': 5.2197275360409305} # lost: 0
limits['WS_cis/GU/min_dist/100.00'] = {'max': 2.6097944096288246, 'min': 1.4641971220030796} # lost: 0
limits['WS_cis/GU/min_dist/95.00'] = {'max': 2.5350810389779777, 'min': 1.5366314729660415} # lost: 21
limits['WS_cis/GU/min_dist/99.00'] = {'max': 2.5991160577875858, 'min': 1.4755870608615591} # lost: 4
limits['WS_cis/GU/min_dist/99.50'] = {'max': 2.6013032548288573, 'min': 1.4719382077253607} # lost: 2
limits['WS_cis/GU/min_dist/99.90'] = {'max': 2.6097944096288246, 'min': 1.4641971220030796} # lost: 0
limits['WS_cis/GU/min_dist/99.99'] = {'max': 2.6097944096288246, 'min': 1.4641971220030796} # lost: 0
limits['WS_cis/GU/n2_z/100.00'] = {'max': -0.69844061, 'min': -0.99952221} # lost: 0
limits['WS_cis/GU/n2_z/95.00'] = {'max': -0.81400818, 'min': -0.99952221} # lost: 21
limits['WS_cis/GU/n2_z/99.00'] = {'max': -0.70996636, 'min': -0.99952221} # lost: 4
limits['WS_cis/GU/n2_z/99.50'] = {'max': -0.70153838, 'min': -0.99952221} # lost: 2
limits['WS_cis/GU/n2_z/99.90'] = {'max': -0.69844061, 'min': -0.99952221} # lost: 0
limits['WS_cis/GU/n2_z/99.99'] = {'max': -0.69844061, 'min': -0.99952221} # lost: 0
limits['WS_cis/GU/nn_ang_norm/100.00'] = {'max': 46.030156109755325, 'min': 1.1582584704944168} # lost: 0
limits['WS_cis/GU/nn_ang_norm/95.00'] = {'max': 35.997673728517128, 'min': 1.1582584704944168} # lost: 21
limits['WS_cis/GU/nn_ang_norm/99.00'] = {'max': 44.812251418472016, 'min': 1.1582584704944168} # lost: 4
limits['WS_cis/GU/nn_ang_norm/99.50'] = {'max': 45.392025195979386, 'min': 1.1582584704944168} # lost: 2
limits['WS_cis/GU/nn_ang_norm/99.90'] = {'max': 46.030156109755325, 'min': 1.1582584704944168} # lost: 0
limits['WS_cis/GU/nn_ang_norm/99.99'] = {'max': 46.030156109755325, 'min': 1.1582584704944168} # lost: 0
limits['WS_cis/GU/rot_ang/100.00'] = {'max': 52.468102773972696, 'min': -50.028216710196247} # lost: 0
limits['WS_cis/GU/rot_ang/95.00'] = {'max': 43.50989623722662, 'min': -40.200566734626321} # lost: 21
limits['WS_cis/GU/rot_ang/99.00'] = {'max': 49.026208580493716, 'min': -42.906001863319133} # lost: 4
limits['WS_cis/GU/rot_ang/99.50'] = {'max': 49.74642103720295, 'min': -43.066572772589218} # lost: 2
limits['WS_cis/GU/rot_ang/99.90'] = {'max': 52.468102773972696, 'min': -50.028216710196247} # lost: 0
limits['WS_cis/GU/rot_ang/99.99'] = {'max': 52.468102773972696, 'min': -50.028216710196247} # lost: 0
limits['WS_cis/UA/dist/100.00'] = {'max': 6.082101045099586, 'min': 5.1819624823719135} # lost: 0
limits['WS_cis/UA/dist/95.00'] = {'max': 5.9242437624755482, 'min': 5.3271240884879765} # lost: 34
limits['WS_cis/UA/dist/99.00'] = {'max': 6.047960664031244, 'min': 5.225379670041213} # lost: 6
limits['WS_cis/UA/dist/99.50'] = {'max': 6.0567038492091001, 'min': 5.1930159834229173} # lost: 3
limits['WS_cis/UA/dist/99.90'] = {'max': 6.082101045099586, 'min': 5.1819624823719135} # lost: 0
limits['WS_cis/UA/dist/99.99'] = {'max': 6.082101045099586, 'min': 5.1819624823719135} # lost: 0
limits['WS_cis/UA/min_dist/100.00'] = {'max': 2.5271223940461649, 'min': 1.5337328171458922} # lost: 0
limits['WS_cis/UA/min_dist/95.00'] = {'max': 2.3489009199066171, 'min': 1.7309366911605755} # lost: 34
limits['WS_cis/UA/min_dist/99.00'] = {'max': 2.5146570121143577, 'min': 1.6346269149724062} # lost: 6
limits['WS_cis/UA/min_dist/99.50'] = {'max': 2.5176844132527738, 'min': 1.6085445135477803} # lost: 3
limits['WS_cis/UA/min_dist/99.90'] = {'max': 2.5271223940461649, 'min': 1.5337328171458922} # lost: 0
limits['WS_cis/UA/min_dist/99.99'] = {'max': 2.5271223940461649, 'min': 1.5337328171458922} # lost: 0
limits['WS_cis/UA/n2_z/100.00'] = {'max': -0.58227032, 'min': -0.9990052} # lost: 0
limits['WS_cis/UA/n2_z/95.00'] = {'max': -0.74270958, 'min': -0.9990052} # lost: 34
limits['WS_cis/UA/n2_z/99.00'] = {'max': -0.65139955, 'min': -0.9990052} # lost: 6
limits['WS_cis/UA/n2_z/99.50'] = {'max': -0.63583589, 'min': -0.9990052} # lost: 3
limits['WS_cis/UA/n2_z/99.90'] = {'max': -0.58227032, 'min': -0.9990052} # lost: 0
limits['WS_cis/UA/n2_z/99.99'] = {'max': -0.58227032, 'min': -0.9990052} # lost: 0
limits['WS_cis/UA/nn_ang_norm/100.00'] = {'max': 52.453457250532082, 'min': 5.0285032014121214} # lost: 0
limits['WS_cis/UA/nn_ang_norm/95.00'] = {'max': 42.305271464753872, 'min': 5.0285032014121214} # lost: 34
limits['WS_cis/UA/nn_ang_norm/99.00'] = {'max': 49.929756993725732, 'min': 5.0285032014121214} # lost: 6
limits['WS_cis/UA/nn_ang_norm/99.50'] = {'max': 51.419202685652067, 'min': 5.0285032014121214} # lost: 3
limits['WS_cis/UA/nn_ang_norm/99.90'] = {'max': 52.453457250532082, 'min': 5.0285032014121214} # lost: 0
limits['WS_cis/UA/nn_ang_norm/99.99'] = {'max': 52.453457250532082, 'min': 5.0285032014121214} # lost: 0
limits['WS_cis/UA/rot_ang/100.00'] = {'max': 49.585379296094551, 'min': -66.000619466056918} # lost: 0
limits['WS_cis/UA/rot_ang/95.00'] = {'max': -20.410940738870288, 'min': -55.164968956719569} # lost: 34
limits['WS_cis/UA/rot_ang/99.00'] = {'max': -16.198729584632396, 'min': -59.622656565465256} # lost: 6
limits['WS_cis/UA/rot_ang/99.50'] = {'max': 7.2649581329931392, 'min': -64.925860775204583} # lost: 3
limits['WS_cis/UA/rot_ang/99.90'] = {'max': 49.585379296094551, 'min': -66.000619466056918} # lost: 0
limits['WS_cis/UA/rot_ang/99.99'] = {'max': 49.585379296094551, 'min': -66.000619466056918} # lost: 0
limits['WS_cis/UC/dist/100.00'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['WS_cis/UC/dist/95.00'] = {'max': 6.7777908828735294, 'min': 5.8837054383083176} # lost: 3
limits['WS_cis/UC/dist/99.00'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['WS_cis/UC/dist/99.50'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['WS_cis/UC/dist/99.90'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['WS_cis/UC/dist/99.99'] = {'max': 6.900526394945623, 'min': 5.8126361598595642} # lost: 0
limits['WS_cis/UC/min_dist/100.00'] = {'max': 2.3539584661598996, 'min': 1.4675819989688403} # lost: 0
limits['WS_cis/UC/min_dist/95.00'] = {'max': 2.242201012507143, 'min': 1.5001182746766484} # lost: 3
limits['WS_cis/UC/min_dist/99.00'] = {'max': 2.3539584661598996, 'min': 1.4675819989688403} # lost: 0
limits['WS_cis/UC/min_dist/99.50'] = {'max': 2.3539584661598996, 'min': 1.4675819989688403} # lost: 0
limits['WS_cis/UC/min_dist/99.90'] = {'max': 2.3539584661598996, 'min': 1.4675819989688403} # lost: 0
limits['WS_cis/UC/min_dist/99.99'] = {'max': 2.3539584661598996, 'min': 1.4675819989688403} # lost: 0
limits['WS_cis/UC/n2_z/100.00'] = {'max': -0.43348521, 'min': -0.9721638} # lost: 0
limits['WS_cis/UC/n2_z/95.00'] = {'max': -0.44524175, 'min': -0.9721638} # lost: 3
limits['WS_cis/UC/n2_z/99.00'] = {'max': -0.43348521, 'min': -0.9721638} # lost: 0
limits['WS_cis/UC/n2_z/99.50'] = {'max': -0.43348521, 'min': -0.9721638} # lost: 0
limits['WS_cis/UC/n2_z/99.90'] = {'max': -0.43348521, 'min': -0.9721638} # lost: 0
limits['WS_cis/UC/n2_z/99.99'] = {'max': -0.43348521, 'min': -0.9721638} # lost: 0
limits['WS_cis/UC/nn_ang_norm/100.00'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['WS_cis/UC/nn_ang_norm/95.00'] = {'max': 63.56707661511328, 'min': 13.648010688671434} # lost: 3
limits['WS_cis/UC/nn_ang_norm/99.00'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['WS_cis/UC/nn_ang_norm/99.50'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['WS_cis/UC/nn_ang_norm/99.90'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['WS_cis/UC/nn_ang_norm/99.99'] = {'max': 64.367957276432293, 'min': 13.648010688671434} # lost: 0
limits['WS_cis/UC/rot_ang/100.00'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['WS_cis/UC/rot_ang/95.00'] = {'max': -24.464540683235242, 'min': -85.270814190973198} # lost: 3
limits['WS_cis/UC/rot_ang/99.00'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['WS_cis/UC/rot_ang/99.50'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['WS_cis/UC/rot_ang/99.90'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['WS_cis/UC/rot_ang/99.99'] = {'max': 17.450814728814997, 'min': -85.270835699510741} # lost: 0
limits['WS_cis/UG/dist/100.00'] = {'max': 7.2656572727775286, 'min': 5.1118656397957469} # lost: 0
limits['WS_cis/UG/dist/95.00'] = {'max': 6.8420421749787614, 'min': 5.5738972776348188} # lost: 29
limits['WS_cis/UG/dist/99.00'] = {'max': 6.9903680019817571, 'min': 5.3121293744702651} # lost: 5
limits['WS_cis/UG/dist/99.50'] = {'max': 7.1562409149949326, 'min': 5.2621126218394441} # lost: 2
limits['WS_cis/UG/dist/99.90'] = {'max': 7.2656572727775286, 'min': 5.1118656397957469} # lost: 0
limits['WS_cis/UG/dist/99.99'] = {'max': 7.2656572727775286, 'min': 5.1118656397957469} # lost: 0
limits['WS_cis/UG/min_dist/100.00'] = {'max': 2.5665968599715581, 'min': 1.3209897946757871} # lost: 0
limits['WS_cis/UG/min_dist/95.00'] = {'max': 2.4147968720368458, 'min': 1.5298983236857411} # lost: 29
limits['WS_cis/UG/min_dist/99.00'] = {'max': 2.5167357435941038, 'min': 1.3432233864916414} # lost: 5
limits['WS_cis/UG/min_dist/99.50'] = {'max': 2.5405399763878407, 'min': 1.3238217210752055} # lost: 2
limits['WS_cis/UG/min_dist/99.90'] = {'max': 2.5665968599715581, 'min': 1.3209897946757871} # lost: 0
limits['WS_cis/UG/min_dist/99.99'] = {'max': 2.5665968599715581, 'min': 1.3209897946757871} # lost: 0
limits['WS_cis/UG/n2_z/100.00'] = {'max': -0.43479949, 'min': -0.98447949} # lost: 0
limits['WS_cis/UG/n2_z/95.00'] = {'max': -0.58780515, 'min': -0.98447949} # lost: 29
limits['WS_cis/UG/n2_z/99.00'] = {'max': -0.50016731, 'min': -0.98447949} # lost: 5
limits['WS_cis/UG/n2_z/99.50'] = {'max': -0.45450693, 'min': -0.98447949} # lost: 2
limits['WS_cis/UG/n2_z/99.90'] = {'max': -0.43479949, 'min': -0.98447949} # lost: 0
limits['WS_cis/UG/n2_z/99.99'] = {'max': -0.43479949, 'min': -0.98447949} # lost: 0
limits['WS_cis/UG/nn_ang_norm/100.00'] = {'max': 64.815389308581487, 'min': 8.6940744836611827} # lost: 0
limits['WS_cis/UG/nn_ang_norm/95.00'] = {'max': 54.044344912011454, 'min': 8.6940744836611827} # lost: 29
limits['WS_cis/UG/nn_ang_norm/99.00'] = {'max': 61.786323355085898, 'min': 8.6940744836611827} # lost: 5
limits['WS_cis/UG/nn_ang_norm/99.50'] = {'max': 64.220343228089973, 'min': 8.6940744836611827} # lost: 2
limits['WS_cis/UG/nn_ang_norm/99.90'] = {'max': 64.815389308581487, 'min': 8.6940744836611827} # lost: 0
limits['WS_cis/UG/nn_ang_norm/99.99'] = {'max': 64.815389308581487, 'min': 8.6940744836611827} # lost: 0
limits['WS_cis/UG/rot_ang/100.00'] = {'max': 55.141907533819385, 'min': -77.182883712551501} # lost: 0
limits['WS_cis/UG/rot_ang/95.00'] = {'max': -25.218028291180179, 'min': -67.83294735696191} # lost: 29
limits['WS_cis/UG/rot_ang/99.00'] = {'max': 42.590120835657949, 'min': -76.955947275861334} # lost: 5
limits['WS_cis/UG/rot_ang/99.50'] = {'max': 54.536636208693743, 'min': -77.165412703734532} # lost: 2
limits['WS_cis/UG/rot_ang/99.90'] = {'max': 55.141907533819385, 'min': -77.182883712551501} # lost: 0
limits['WS_cis/UG/rot_ang/99.99'] = {'max': 55.141907533819385, 'min': -77.182883712551501} # lost: 0
limits['WS_cis/UU/dist/100.00'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['WS_cis/UU/dist/95.00'] = {'max': 6.8628254274157809, 'min': 6.1056794042907097} # lost: 3
limits['WS_cis/UU/dist/99.00'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['WS_cis/UU/dist/99.50'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['WS_cis/UU/dist/99.90'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['WS_cis/UU/dist/99.99'] = {'max': 7.174348092971119, 'min': 6.0387989672150022} # lost: 0
limits['WS_cis/UU/min_dist/100.00'] = {'max': 2.4464407249840914, 'min': 1.5584590867922792} # lost: 0
limits['WS_cis/UU/min_dist/95.00'] = {'max': 2.2852666974310636, 'min': 1.6964407931566423} # lost: 3
limits['WS_cis/UU/min_dist/99.00'] = {'max': 2.4464407249840914, 'min': 1.5584590867922792} # lost: 0
limits['WS_cis/UU/min_dist/99.50'] = {'max': 2.4464407249840914, 'min': 1.5584590867922792} # lost: 0
limits['WS_cis/UU/min_dist/99.90'] = {'max': 2.4464407249840914, 'min': 1.5584590867922792} # lost: 0
limits['WS_cis/UU/min_dist/99.99'] = {'max': 2.4464407249840914, 'min': 1.5584590867922792} # lost: 0
limits['WS_cis/UU/n2_z/100.00'] = {'max': -0.70797586, 'min': -0.9926008} # lost: 0
limits['WS_cis/UU/n2_z/95.00'] = {'max': -0.75122005, 'min': -0.9926008} # lost: 3
limits['WS_cis/UU/n2_z/99.00'] = {'max': -0.70797586, 'min': -0.9926008} # lost: 0
limits['WS_cis/UU/n2_z/99.50'] = {'max': -0.70797586, 'min': -0.9926008} # lost: 0
limits['WS_cis/UU/n2_z/99.90'] = {'max': -0.70797586, 'min': -0.9926008} # lost: 0
limits['WS_cis/UU/n2_z/99.99'] = {'max': -0.70797586, 'min': -0.9926008} # lost: 0
limits['WS_cis/UU/nn_ang_norm/100.00'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['WS_cis/UU/nn_ang_norm/95.00'] = {'max': 42.957581851246772, 'min': 11.758274930247325} # lost: 3
limits['WS_cis/UU/nn_ang_norm/99.00'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['WS_cis/UU/nn_ang_norm/99.50'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['WS_cis/UU/nn_ang_norm/99.90'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['WS_cis/UU/nn_ang_norm/99.99'] = {'max': 46.161405024846289, 'min': 11.758274930247325} # lost: 0
limits['WS_cis/UU/rot_ang/100.00'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['WS_cis/UU/rot_ang/95.00'] = {'max': 37.69802738578398, 'min': -52.962406468377985} # lost: 3
limits['WS_cis/UU/rot_ang/99.00'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['WS_cis/UU/rot_ang/99.50'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['WS_cis/UU/rot_ang/99.90'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['WS_cis/UU/rot_ang/99.99'] = {'max': 43.683272945073185, 'min': -57.406254623070126} # lost: 0
limits['WS_tran/AA/dist/100.00'] = {'max': 6.5410713628001007, 'min': 5.3468447587376993} # lost: 0
limits['WS_tran/AA/dist/95.00'] = {'max': 6.2190527867852126, 'min': 5.433459557681994} # lost: 13
limits['WS_tran/AA/dist/99.00'] = {'max': 6.538613288516764, 'min': 5.3483630186890911} # lost: 2
limits['WS_tran/AA/dist/99.50'] = {'max': 6.538613288516764, 'min': 5.3468447587376993} # lost: 1
limits['WS_tran/AA/dist/99.90'] = {'max': 6.5410713628001007, 'min': 5.3468447587376993} # lost: 0
limits['WS_tran/AA/dist/99.99'] = {'max': 6.5410713628001007, 'min': 5.3468447587376993} # lost: 0
limits['WS_tran/AA/min_dist/100.00'] = {'max': 2.5159158944121627, 'min': 1.3433073118508145} # lost: 0
limits['WS_tran/AA/min_dist/95.00'] = {'max': 2.4543976747203642, 'min': 1.6787443164117615} # lost: 13
limits['WS_tran/AA/min_dist/99.00'] = {'max': 2.5122083863470128, 'min': 1.5148124472821431} # lost: 2
limits['WS_tran/AA/min_dist/99.50'] = {'max': 2.5122083863470128, 'min': 1.3433073118508145} # lost: 1
limits['WS_tran/AA/min_dist/99.90'] = {'max': 2.5159158944121627, 'min': 1.3433073118508145} # lost: 0
limits['WS_tran/AA/min_dist/99.99'] = {'max': 2.5159158944121627, 'min': 1.3433073118508145} # lost: 0
limits['WS_tran/AA/n2_z/100.00'] = {'max': 0.9978621, 'min': 0.51667881} # lost: 0
limits['WS_tran/AA/n2_z/95.00'] = {'max': 0.9978621, 'min': 0.83813936} # lost: 13
limits['WS_tran/AA/n2_z/99.00'] = {'max': 0.9978621, 'min': 0.7441113} # lost: 2
limits['WS_tran/AA/n2_z/99.50'] = {'max': 0.9978621, 'min': 0.71946537} # lost: 1
limits['WS_tran/AA/n2_z/99.90'] = {'max': 0.9978621, 'min': 0.51667881} # lost: 0
limits['WS_tran/AA/n2_z/99.99'] = {'max': 0.9978621, 'min': 0.51667881} # lost: 0
limits['WS_tran/AA/nn_ang_norm/100.00'] = {'max': 60.202769495542277, 'min': 3.5739075822665733} # lost: 0
limits['WS_tran/AA/nn_ang_norm/95.00'] = {'max': 33.290796222221957, 'min': 3.5739075822665733} # lost: 13
limits['WS_tran/AA/nn_ang_norm/99.00'] = {'max': 42.612354948604803, 'min': 3.5739075822665733} # lost: 2
limits['WS_tran/AA/nn_ang_norm/99.50'] = {'max': 44.072895279963646, 'min': 3.5739075822665733} # lost: 1
limits['WS_tran/AA/nn_ang_norm/99.90'] = {'max': 60.202769495542277, 'min': 3.5739075822665733} # lost: 0
limits['WS_tran/AA/nn_ang_norm/99.99'] = {'max': 60.202769495542277, 'min': 3.5739075822665733} # lost: 0
limits['WS_tran/AA/rot_ang/100.00'] = {'max2': -67.799581591364699, 'min1': 260.84343160444928, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AA/rot_ang/95.00'] = {'max2': -78.959172746995648, 'min1': 262.10558113461309, 'min2': -90.0, 'max1': 270.0} # lost: 13
limits['WS_tran/AA/rot_ang/99.00'] = {'max2': -75.287720442847956, 'min1': 261.11990869079375, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['WS_tran/AA/rot_ang/99.50'] = {'max2': -75.287720442847956, 'min1': 260.84343160444928, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['WS_tran/AA/rot_ang/99.90'] = {'max2': -67.799581591364699, 'min1': 260.84343160444928, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AA/rot_ang/99.99'] = {'max2': -67.799581591364699, 'min1': 260.84343160444928, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AC/dist/100.00'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['WS_tran/AC/dist/95.00'] = {'max': 7.8475875402067672, 'min': 7.3262570523448201} # lost: 3
limits['WS_tran/AC/dist/99.00'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['WS_tran/AC/dist/99.50'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['WS_tran/AC/dist/99.90'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['WS_tran/AC/dist/99.99'] = {'max': 7.8629039873780417, 'min': 7.2860079167016663} # lost: 0
limits['WS_tran/AC/min_dist/100.00'] = {'max': 2.1769292306258214, 'min': 1.4794694412769951} # lost: 0
limits['WS_tran/AC/min_dist/95.00'] = {'max': 2.1395579615543641, 'min': 1.7733349438929538} # lost: 3
limits['WS_tran/AC/min_dist/99.00'] = {'max': 2.1769292306258214, 'min': 1.4794694412769951} # lost: 0
limits['WS_tran/AC/min_dist/99.50'] = {'max': 2.1769292306258214, 'min': 1.4794694412769951} # lost: 0
limits['WS_tran/AC/min_dist/99.90'] = {'max': 2.1769292306258214, 'min': 1.4794694412769951} # lost: 0
limits['WS_tran/AC/min_dist/99.99'] = {'max': 2.1769292306258214, 'min': 1.4794694412769951} # lost: 0
limits['WS_tran/AC/n2_z/100.00'] = {'max': 0.99430567, 'min': 0.91808432} # lost: 0
limits['WS_tran/AC/n2_z/95.00'] = {'max': 0.99430567, 'min': 0.9441669} # lost: 3
limits['WS_tran/AC/n2_z/99.00'] = {'max': 0.99430567, 'min': 0.91808432} # lost: 0
limits['WS_tran/AC/n2_z/99.50'] = {'max': 0.99430567, 'min': 0.91808432} # lost: 0
limits['WS_tran/AC/n2_z/99.90'] = {'max': 0.99430567, 'min': 0.91808432} # lost: 0
limits['WS_tran/AC/n2_z/99.99'] = {'max': 0.99430567, 'min': 0.91808432} # lost: 0
limits['WS_tran/AC/nn_ang_norm/100.00'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['WS_tran/AC/nn_ang_norm/95.00'] = {'max': 19.791045148454934, 'min': 7.394410606779994} # lost: 3
limits['WS_tran/AC/nn_ang_norm/99.00'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['WS_tran/AC/nn_ang_norm/99.50'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['WS_tran/AC/nn_ang_norm/99.90'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['WS_tran/AC/nn_ang_norm/99.99'] = {'max': 23.609231885066077, 'min': 7.394410606779994} # lost: 0
limits['WS_tran/AC/rot_ang/100.00'] = {'max': -57.420469621513185, 'min': -69.987099938378918} # lost: 0
limits['WS_tran/AC/rot_ang/95.00'] = {'max': -58.189067339515731, 'min': -66.674747005599443} # lost: 3
limits['WS_tran/AC/rot_ang/99.00'] = {'max': -57.420469621513185, 'min': -69.987099938378918} # lost: 0
limits['WS_tran/AC/rot_ang/99.50'] = {'max': -57.420469621513185, 'min': -69.987099938378918} # lost: 0
limits['WS_tran/AC/rot_ang/99.90'] = {'max': -57.420469621513185, 'min': -69.987099938378918} # lost: 0
limits['WS_tran/AC/rot_ang/99.99'] = {'max': -57.420469621513185, 'min': -69.987099938378918} # lost: 0
limits['WS_tran/AG/dist/100.00'] = {'max': 7.1362829073812364, 'min': 5.3788444386177243} # lost: 0
limits['WS_tran/AG/dist/95.00'] = {'max': 6.7177254257783368, 'min': 5.7656631712363913} # lost: 206
limits['WS_tran/AG/dist/99.00'] = {'max': 6.9279836467222546, 'min': 5.6034389778934823} # lost: 41
limits['WS_tran/AG/dist/99.50'] = {'max': 6.9673405081596433, 'min': 5.5660111413216722} # lost: 20
limits['WS_tran/AG/dist/99.90'] = {'max': 7.0816749823375282, 'min': 5.3959175643872541} # lost: 4
limits['WS_tran/AG/dist/99.99'] = {'max': 7.1362829073812364, 'min': 5.3788444386177243} # lost: 0
limits['WS_tran/AG/min_dist/100.00'] = {'max': 2.9957810340349278, 'min': 0.84099071335041853} # lost: 0
limits['WS_tran/AG/min_dist/95.00'] = {'max': 2.4643132108753281, 'min': 1.5187867433407243} # lost: 206
limits['WS_tran/AG/min_dist/99.00'] = {'max': 2.6252000181932127, 'min': 1.2697210765276907} # lost: 41
limits['WS_tran/AG/min_dist/99.50'] = {'max': 2.7275601979579562, 'min': 1.1749332854750527} # lost: 20
limits['WS_tran/AG/min_dist/99.90'] = {'max': 2.8239682816536651, 'min': 1.0345996028819759} # lost: 4
limits['WS_tran/AG/min_dist/99.99'] = {'max': 2.9957810340349278, 'min': 0.84099071335041853} # lost: 0
limits['WS_tran/AG/n2_z/100.00'] = {'max': 0.99994445, 'min': 0.41961145} # lost: 0
limits['WS_tran/AG/n2_z/95.00'] = {'max': 0.99994445, 'min': 0.67413974} # lost: 206
limits['WS_tran/AG/n2_z/99.00'] = {'max': 0.99994445, 'min': 0.46093008} # lost: 41
limits['WS_tran/AG/n2_z/99.50'] = {'max': 0.99994445, 'min': 0.44648239} # lost: 20
limits['WS_tran/AG/n2_z/99.90'] = {'max': 0.99994445, 'min': 0.42632148} # lost: 4
limits['WS_tran/AG/n2_z/99.99'] = {'max': 0.99994445, 'min': 0.41961145} # lost: 0
limits['WS_tran/AG/nn_ang_norm/100.00'] = {'max': 64.928625193598293, 'min': 0.57505299621297279} # lost: 0
limits['WS_tran/AG/nn_ang_norm/95.00'] = {'max': 47.394054273314836, 'min': 0.57505299621297279} # lost: 206
limits['WS_tran/AG/nn_ang_norm/99.00'] = {'max': 62.543120154268806, 'min': 0.57505299621297279} # lost: 41
limits['WS_tran/AG/nn_ang_norm/99.50'] = {'max': 63.415444594306159, 'min': 0.57505299621297279} # lost: 20
limits['WS_tran/AG/nn_ang_norm/99.90'] = {'max': 64.676591213224825, 'min': 0.57505299621297279} # lost: 4
limits['WS_tran/AG/nn_ang_norm/99.99'] = {'max': 64.928625193598293, 'min': 0.57505299621297279} # lost: 0
limits['WS_tran/AG/rot_ang/100.00'] = {'max2': -48.248226678611047, 'min1': 229.52348594689616, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AG/rot_ang/95.00'] = {'max2': -57.965318161721029, 'min1': 236.57736904575714, 'min2': -90.0, 'max1': 270.0} # lost: 206
limits['WS_tran/AG/rot_ang/99.00'] = {'max2': -52.769853428074214, 'min1': 232.5541789840461, 'min2': -90.0, 'max1': 270.0} # lost: 41
limits['WS_tran/AG/rot_ang/99.50'] = {'max2': -52.010675342256263, 'min1': 231.67838115763843, 'min2': -90.0, 'max1': 270.0} # lost: 20
limits['WS_tran/AG/rot_ang/99.90'] = {'max2': -48.702830638245757, 'min1': 230.77302451841376, 'min2': -90.0, 'max1': 270.0} # lost: 4
limits['WS_tran/AG/rot_ang/99.99'] = {'max2': -48.248226678611047, 'min1': 229.52348594689616, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AU/dist/100.00'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['WS_tran/AU/dist/95.00'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['WS_tran/AU/dist/99.00'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['WS_tran/AU/dist/99.50'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['WS_tran/AU/dist/99.90'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['WS_tran/AU/dist/99.99'] = {'max': 8.0925820406345856, 'min': 5.8276783890438724} # lost: 0
limits['WS_tran/AU/min_dist/100.00'] = {'max': 2.3770017761035742, 'min': 1.5763671664967733} # lost: 0
limits['WS_tran/AU/min_dist/95.00'] = {'max': 2.3770017761035742, 'min': 1.5763671664967733} # lost: 0
limits['WS_tran/AU/min_dist/99.00'] = {'max': 2.3770017761035742, 'min': 1.5763671664967733} # lost: 0
limits['WS_tran/AU/min_dist/99.50'] = {'max': 2.3770017761035742, 'min': 1.5763671664967733} # lost: 0
limits['WS_tran/AU/min_dist/99.90'] = {'max': 2.3770017761035742, 'min': 1.5763671664967733} # lost: 0
limits['WS_tran/AU/min_dist/99.99'] = {'max': 2.3770017761035742, 'min': 1.5763671664967733} # lost: 0
limits['WS_tran/AU/n2_z/100.00'] = {'max': 0.93432868, 'min': 0.67908847} # lost: 0
limits['WS_tran/AU/n2_z/95.00'] = {'max': 0.93432868, 'min': 0.67908847} # lost: 0
limits['WS_tran/AU/n2_z/99.00'] = {'max': 0.93432868, 'min': 0.67908847} # lost: 0
limits['WS_tran/AU/n2_z/99.50'] = {'max': 0.93432868, 'min': 0.67908847} # lost: 0
limits['WS_tran/AU/n2_z/99.90'] = {'max': 0.93432868, 'min': 0.67908847} # lost: 0
limits['WS_tran/AU/n2_z/99.99'] = {'max': 0.93432868, 'min': 0.67908847} # lost: 0
limits['WS_tran/AU/nn_ang_norm/100.00'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['WS_tran/AU/nn_ang_norm/95.00'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['WS_tran/AU/nn_ang_norm/99.00'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['WS_tran/AU/nn_ang_norm/99.50'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['WS_tran/AU/nn_ang_norm/99.90'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['WS_tran/AU/nn_ang_norm/99.99'] = {'max': 47.095571591490696, 'min': 21.55279511466405} # lost: 0
limits['WS_tran/AU/rot_ang/100.00'] = {'max2': -52.919530319215653, 'min1': 224.53559813880429, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AU/rot_ang/95.00'] = {'max2': -52.919530319215653, 'min1': 224.53559813880429, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AU/rot_ang/99.00'] = {'max2': -52.919530319215653, 'min1': 224.53559813880429, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AU/rot_ang/99.50'] = {'max2': -52.919530319215653, 'min1': 224.53559813880429, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AU/rot_ang/99.90'] = {'max2': -52.919530319215653, 'min1': 224.53559813880429, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/AU/rot_ang/99.99'] = {'max2': -52.919530319215653, 'min1': 224.53559813880429, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CA/dist/100.00'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['WS_tran/CA/dist/95.00'] = {'max': 7.0550958390033713, 'min': 5.7463047426132867} # lost: 3
limits['WS_tran/CA/dist/99.00'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['WS_tran/CA/dist/99.50'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['WS_tran/CA/dist/99.90'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['WS_tran/CA/dist/99.99'] = {'max': 7.0816228177279603, 'min': 5.702668412044118} # lost: 0
limits['WS_tran/CA/min_dist/100.00'] = {'max': 2.4956113206527606, 'min': 1.4039519171475372} # lost: 0
limits['WS_tran/CA/min_dist/95.00'] = {'max': 2.4468128329170247, 'min': 1.517124359755099} # lost: 3
limits['WS_tran/CA/min_dist/99.00'] = {'max': 2.4956113206527606, 'min': 1.4039519171475372} # lost: 0
limits['WS_tran/CA/min_dist/99.50'] = {'max': 2.4956113206527606, 'min': 1.4039519171475372} # lost: 0
limits['WS_tran/CA/min_dist/99.90'] = {'max': 2.4956113206527606, 'min': 1.4039519171475372} # lost: 0
limits['WS_tran/CA/min_dist/99.99'] = {'max': 2.4956113206527606, 'min': 1.4039519171475372} # lost: 0
limits['WS_tran/CA/n2_z/100.00'] = {'max': 0.95969248, 'min': 0.67968553} # lost: 0
limits['WS_tran/CA/n2_z/95.00'] = {'max': 0.95969248, 'min': 0.73086858} # lost: 3
limits['WS_tran/CA/n2_z/99.00'] = {'max': 0.95969248, 'min': 0.67968553} # lost: 0
limits['WS_tran/CA/n2_z/99.50'] = {'max': 0.95969248, 'min': 0.67968553} # lost: 0
limits['WS_tran/CA/n2_z/99.90'] = {'max': 0.95969248, 'min': 0.67968553} # lost: 0
limits['WS_tran/CA/n2_z/99.99'] = {'max': 0.95969248, 'min': 0.67968553} # lost: 0
limits['WS_tran/CA/nn_ang_norm/100.00'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['WS_tran/CA/nn_ang_norm/95.00'] = {'max': 42.207877976145816, 'min': 16.331226484763317} # lost: 3
limits['WS_tran/CA/nn_ang_norm/99.00'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['WS_tran/CA/nn_ang_norm/99.50'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['WS_tran/CA/nn_ang_norm/99.90'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['WS_tran/CA/nn_ang_norm/99.99'] = {'max': 45.7367635127246, 'min': 16.331226484763317} # lost: 0
limits['WS_tran/CA/rot_ang/100.00'] = {'max2': -53.114485532916888, 'min1': 260.38501760523457, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CA/rot_ang/95.00'] = {'max2': -55.809706153173295, 'min1': 274.97021447594398, 'min2': -90.0, 'max1': 270.0} # lost: 3
limits['WS_tran/CA/rot_ang/99.00'] = {'max2': -53.114485532916888, 'min1': 260.38501760523457, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CA/rot_ang/99.50'] = {'max2': -53.114485532916888, 'min1': 260.38501760523457, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CA/rot_ang/99.90'] = {'max2': -53.114485532916888, 'min1': 260.38501760523457, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CA/rot_ang/99.99'] = {'max2': -53.114485532916888, 'min1': 260.38501760523457, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CC/dist/100.00'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['WS_tran/CC/dist/95.00'] = {'max': 7.6926000461578292, 'min': 6.9755181642732698} # lost: 2
limits['WS_tran/CC/dist/99.00'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['WS_tran/CC/dist/99.50'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['WS_tran/CC/dist/99.90'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['WS_tran/CC/dist/99.99'] = {'max': 7.8078181034999359, 'min': 6.6892106205854036} # lost: 0
limits['WS_tran/CC/min_dist/100.00'] = {'max': 2.4108090096743391, 'min': 1.6212414497314989} # lost: 0
limits['WS_tran/CC/min_dist/95.00'] = {'max': 2.3695979431377321, 'min': 1.7071320101610734} # lost: 2
limits['WS_tran/CC/min_dist/99.00'] = {'max': 2.4108090096743391, 'min': 1.6212414497314989} # lost: 0
limits['WS_tran/CC/min_dist/99.50'] = {'max': 2.4108090096743391, 'min': 1.6212414497314989} # lost: 0
limits['WS_tran/CC/min_dist/99.90'] = {'max': 2.4108090096743391, 'min': 1.6212414497314989} # lost: 0
limits['WS_tran/CC/min_dist/99.99'] = {'max': 2.4108090096743391, 'min': 1.6212414497314989} # lost: 0
limits['WS_tran/CC/n2_z/100.00'] = {'max': 0.94986695, 'min': 0.61337465} # lost: 0
limits['WS_tran/CC/n2_z/95.00'] = {'max': 0.94986695, 'min': 0.72716635} # lost: 2
limits['WS_tran/CC/n2_z/99.00'] = {'max': 0.94986695, 'min': 0.61337465} # lost: 0
limits['WS_tran/CC/n2_z/99.50'] = {'max': 0.94986695, 'min': 0.61337465} # lost: 0
limits['WS_tran/CC/n2_z/99.90'] = {'max': 0.94986695, 'min': 0.61337465} # lost: 0
limits['WS_tran/CC/n2_z/99.99'] = {'max': 0.94986695, 'min': 0.61337465} # lost: 0
limits['WS_tran/CC/nn_ang_norm/100.00'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['WS_tran/CC/nn_ang_norm/95.00'] = {'max': 43.338731906457319, 'min': 17.594777330269824} # lost: 2
limits['WS_tran/CC/nn_ang_norm/99.00'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['WS_tran/CC/nn_ang_norm/99.50'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['WS_tran/CC/nn_ang_norm/99.90'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['WS_tran/CC/nn_ang_norm/99.99'] = {'max': 52.033685663288608, 'min': 17.594777330269824} # lost: 0
limits['WS_tran/CC/rot_ang/100.00'] = {'max2': -80.352986828610312, 'min1': 251.95485684671183, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CC/rot_ang/95.00'] = {'max': 269.5076363107014, 'min': 252.74949958091699} # lost: 2
limits['WS_tran/CC/rot_ang/99.00'] = {'max2': -80.352986828610312, 'min1': 251.95485684671183, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CC/rot_ang/99.50'] = {'max2': -80.352986828610312, 'min1': 251.95485684671183, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CC/rot_ang/99.90'] = {'max2': -80.352986828610312, 'min1': 251.95485684671183, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CC/rot_ang/99.99'] = {'max2': -80.352986828610312, 'min1': 251.95485684671183, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CG/dist/100.00'] = {'max': 6.813238695997045, 'min': 5.1637584658639497} # lost: 0
limits['WS_tran/CG/dist/95.00'] = {'max': 6.5795516353800245, 'min': 5.7057067083366961} # lost: 25
limits['WS_tran/CG/dist/99.00'] = {'max': 6.7072988599762189, 'min': 5.3890355985493708} # lost: 5
limits['WS_tran/CG/dist/99.50'] = {'max': 6.7927714474302547, 'min': 5.2664778149807638} # lost: 2
limits['WS_tran/CG/dist/99.90'] = {'max': 6.813238695997045, 'min': 5.1637584658639497} # lost: 0
limits['WS_tran/CG/dist/99.99'] = {'max': 6.813238695997045, 'min': 5.1637584658639497} # lost: 0
limits['WS_tran/CG/min_dist/100.00'] = {'max': 2.5481069492542163, 'min': 1.1834436707330216} # lost: 0
limits['WS_tran/CG/min_dist/95.00'] = {'max': 2.3856626632648088, 'min': 1.5224474402282777} # lost: 25
limits['WS_tran/CG/min_dist/99.00'] = {'max': 2.50237919395131, 'min': 1.2240350488737144} # lost: 5
limits['WS_tran/CG/min_dist/99.50'] = {'max': 2.5302003022663726, 'min': 1.1911847055253484} # lost: 2
limits['WS_tran/CG/min_dist/99.90'] = {'max': 2.5481069492542163, 'min': 1.1834436707330216} # lost: 0
limits['WS_tran/CG/min_dist/99.99'] = {'max': 2.5481069492542163, 'min': 1.1834436707330216} # lost: 0
limits['WS_tran/CG/n2_z/100.00'] = {'max': 0.99965727, 'min': 0.4824594} # lost: 0
limits['WS_tran/CG/n2_z/95.00'] = {'max': 0.99965727, 'min': 0.67270553} # lost: 25
limits['WS_tran/CG/n2_z/99.00'] = {'max': 0.99965727, 'min': 0.54005486} # lost: 5
limits['WS_tran/CG/n2_z/99.50'] = {'max': 0.99965727, 'min': 0.5066939} # lost: 2
limits['WS_tran/CG/n2_z/99.90'] = {'max': 0.99965727, 'min': 0.4824594} # lost: 0
limits['WS_tran/CG/n2_z/99.99'] = {'max': 0.99965727, 'min': 0.4824594} # lost: 0
limits['WS_tran/CG/nn_ang_norm/100.00'] = {'max': 61.119619938778939, 'min': 1.3508914626312238} # lost: 0
limits['WS_tran/CG/nn_ang_norm/95.00'] = {'max': 47.150120897297001, 'min': 1.3508914626312238} # lost: 25
limits['WS_tran/CG/nn_ang_norm/99.00'] = {'max': 57.198934260840709, 'min': 1.3508914626312238} # lost: 5
limits['WS_tran/CG/nn_ang_norm/99.50'] = {'max': 59.648410851936532, 'min': 1.3508914626312238} # lost: 2
limits['WS_tran/CG/nn_ang_norm/99.90'] = {'max': 61.119619938778939, 'min': 1.3508914626312238} # lost: 0
limits['WS_tran/CG/nn_ang_norm/99.99'] = {'max': 61.119619938778939, 'min': 1.3508914626312238} # lost: 0
limits['WS_tran/CG/rot_ang/100.00'] = {'max2': -61.000659196559923, 'min1': 243.09590006901601, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CG/rot_ang/95.00'] = {'max2': -71.778338034741523, 'min1': 259.32766183350816, 'min2': -90.0, 'max1': 270.0} # lost: 25
limits['WS_tran/CG/rot_ang/99.00'] = {'max2': -66.228285369407445, 'min1': 250.23494854573147, 'min2': -90.0, 'max1': 270.0} # lost: 5
limits['WS_tran/CG/rot_ang/99.50'] = {'max2': -65.661763451205843, 'min1': 245.08080975098619, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['WS_tran/CG/rot_ang/99.90'] = {'max2': -61.000659196559923, 'min1': 243.09590006901601, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CG/rot_ang/99.99'] = {'max2': -61.000659196559923, 'min1': 243.09590006901601, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/CU/dist/100.00'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['WS_tran/CU/dist/95.00'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['WS_tran/CU/dist/99.00'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['WS_tran/CU/dist/99.50'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['WS_tran/CU/dist/99.90'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['WS_tran/CU/dist/99.99'] = {'max': 6.9425823011897556, 'min': 6.9401196405161523} # lost: 0
limits['WS_tran/CU/min_dist/100.00'] = {'max': 1.6381061223784132, 'min': 1.6336460332813738} # lost: 0
limits['WS_tran/CU/min_dist/95.00'] = {'max': 1.6381061223784132, 'min': 1.6336460332813738} # lost: 0
limits['WS_tran/CU/min_dist/99.00'] = {'max': 1.6381061223784132, 'min': 1.6336460332813738} # lost: 0
limits['WS_tran/CU/min_dist/99.50'] = {'max': 1.6381061223784132, 'min': 1.6336460332813738} # lost: 0
limits['WS_tran/CU/min_dist/99.90'] = {'max': 1.6381061223784132, 'min': 1.6336460332813738} # lost: 0
limits['WS_tran/CU/min_dist/99.99'] = {'max': 1.6381061223784132, 'min': 1.6336460332813738} # lost: 0
limits['WS_tran/CU/n2_z/100.00'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['WS_tran/CU/n2_z/95.00'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['WS_tran/CU/n2_z/99.00'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['WS_tran/CU/n2_z/99.50'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['WS_tran/CU/n2_z/99.90'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['WS_tran/CU/n2_z/99.99'] = {'max': 0.92350876, 'min': 0.92315632} # lost: 0
limits['WS_tran/CU/nn_ang_norm/100.00'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['WS_tran/CU/nn_ang_norm/95.00'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['WS_tran/CU/nn_ang_norm/99.00'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['WS_tran/CU/nn_ang_norm/99.50'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['WS_tran/CU/nn_ang_norm/99.90'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['WS_tran/CU/nn_ang_norm/99.99'] = {'max': 22.600658831465314, 'min': 22.586633038004692} # lost: 0
limits['WS_tran/CU/rot_ang/100.00'] = {'max': 253.9858081369855, 'min': 253.97143395308984} # lost: 0
limits['WS_tran/CU/rot_ang/95.00'] = {'max': 253.9858081369855, 'min': 253.97143395308984} # lost: 0
limits['WS_tran/CU/rot_ang/99.00'] = {'max': 253.9858081369855, 'min': 253.97143395308984} # lost: 0
limits['WS_tran/CU/rot_ang/99.50'] = {'max': 253.9858081369855, 'min': 253.97143395308984} # lost: 0
limits['WS_tran/CU/rot_ang/99.90'] = {'max': 253.9858081369855, 'min': 253.97143395308984} # lost: 0
limits['WS_tran/CU/rot_ang/99.99'] = {'max': 253.9858081369855, 'min': 253.97143395308984} # lost: 0
limits['WS_tran/GA/dist/100.00'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['WS_tran/GA/dist/95.00'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['WS_tran/GA/dist/99.00'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['WS_tran/GA/dist/99.50'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['WS_tran/GA/dist/99.90'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['WS_tran/GA/dist/99.99'] = {'max': 6.8839368891349491, 'min': 5.8825031076136156} # lost: 0
limits['WS_tran/GA/min_dist/100.00'] = {'max': 2.3387790068465288, 'min': 1.8965011724785799} # lost: 0
limits['WS_tran/GA/min_dist/95.00'] = {'max': 2.3387790068465288, 'min': 1.8965011724785799} # lost: 0
limits['WS_tran/GA/min_dist/99.00'] = {'max': 2.3387790068465288, 'min': 1.8965011724785799} # lost: 0
limits['WS_tran/GA/min_dist/99.50'] = {'max': 2.3387790068465288, 'min': 1.8965011724785799} # lost: 0
limits['WS_tran/GA/min_dist/99.90'] = {'max': 2.3387790068465288, 'min': 1.8965011724785799} # lost: 0
limits['WS_tran/GA/min_dist/99.99'] = {'max': 2.3387790068465288, 'min': 1.8965011724785799} # lost: 0
limits['WS_tran/GA/n2_z/100.00'] = {'max': 0.94365025, 'min': 0.60013974} # lost: 0
limits['WS_tran/GA/n2_z/95.00'] = {'max': 0.94365025, 'min': 0.60013974} # lost: 0
limits['WS_tran/GA/n2_z/99.00'] = {'max': 0.94365025, 'min': 0.60013974} # lost: 0
limits['WS_tran/GA/n2_z/99.50'] = {'max': 0.94365025, 'min': 0.60013974} # lost: 0
limits['WS_tran/GA/n2_z/99.90'] = {'max': 0.94365025, 'min': 0.60013974} # lost: 0
limits['WS_tran/GA/n2_z/99.99'] = {'max': 0.94365025, 'min': 0.60013974} # lost: 0
limits['WS_tran/GA/nn_ang_norm/100.00'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['WS_tran/GA/nn_ang_norm/95.00'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['WS_tran/GA/nn_ang_norm/99.00'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['WS_tran/GA/nn_ang_norm/99.50'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['WS_tran/GA/nn_ang_norm/99.90'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['WS_tran/GA/nn_ang_norm/99.99'] = {'max': 60.405400717649052, 'min': 19.190323180763144} # lost: 0
limits['WS_tran/GA/rot_ang/100.00'] = {'max2': -85.834526346423786, 'min1': 236.23642509299586, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GA/rot_ang/95.00'] = {'max2': -85.834526346423786, 'min1': 236.23642509299586, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GA/rot_ang/99.00'] = {'max2': -85.834526346423786, 'min1': 236.23642509299586, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GA/rot_ang/99.50'] = {'max2': -85.834526346423786, 'min1': 236.23642509299586, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GA/rot_ang/99.90'] = {'max2': -85.834526346423786, 'min1': 236.23642509299586, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GA/rot_ang/99.99'] = {'max2': -85.834526346423786, 'min1': 236.23642509299586, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GC/dist/100.00'] = {'max': 7.5997016466555376, 'min': 6.0803410734014713} # lost: 0
limits['WS_tran/GC/dist/95.00'] = {'max': 7.434636840487471, 'min': 6.1507279619804063} # lost: 10
limits['WS_tran/GC/dist/99.00'] = {'max': 7.5315087813918309, 'min': 6.0869382678094741} # lost: 2
limits['WS_tran/GC/dist/99.50'] = {'max': 7.5315087813918309, 'min': 6.0803410734014713} # lost: 1
limits['WS_tran/GC/dist/99.90'] = {'max': 7.5997016466555376, 'min': 6.0803410734014713} # lost: 0
limits['WS_tran/GC/dist/99.99'] = {'max': 7.5997016466555376, 'min': 6.0803410734014713} # lost: 0
limits['WS_tran/GC/min_dist/100.00'] = {'max': 2.4803791949511473, 'min': 1.2605474569980111} # lost: 0
limits['WS_tran/GC/min_dist/95.00'] = {'max': 2.3998714998331523, 'min': 1.5262541478463132} # lost: 10
limits['WS_tran/GC/min_dist/99.00'] = {'max': 2.4677224766624883, 'min': 1.3487068537187925} # lost: 2
limits['WS_tran/GC/min_dist/99.50'] = {'max': 2.4677224766624883, 'min': 1.2605474569980111} # lost: 1
limits['WS_tran/GC/min_dist/99.90'] = {'max': 2.4803791949511473, 'min': 1.2605474569980111} # lost: 0
limits['WS_tran/GC/min_dist/99.99'] = {'max': 2.4803791949511473, 'min': 1.2605474569980111} # lost: 0
limits['WS_tran/GC/n2_z/100.00'] = {'max': 0.99944806, 'min': 0.42990065} # lost: 0
limits['WS_tran/GC/n2_z/95.00'] = {'max': 0.99944806, 'min': 0.52403504} # lost: 10
limits['WS_tran/GC/n2_z/99.00'] = {'max': 0.99944806, 'min': 0.44901276} # lost: 2
limits['WS_tran/GC/n2_z/99.50'] = {'max': 0.99944806, 'min': 0.44611719} # lost: 1
limits['WS_tran/GC/n2_z/99.90'] = {'max': 0.99944806, 'min': 0.42990065} # lost: 0
limits['WS_tran/GC/n2_z/99.99'] = {'max': 0.99944806, 'min': 0.42990065} # lost: 0
limits['WS_tran/GC/nn_ang_norm/100.00'] = {'max': 63.773141601139727, 'min': 1.8493853486851997} # lost: 0
limits['WS_tran/GC/nn_ang_norm/95.00'] = {'max': 58.516928544221393, 'min': 1.8493853486851997} # lost: 10
limits['WS_tran/GC/nn_ang_norm/99.00'] = {'max': 62.837542288631376, 'min': 1.8493853486851997} # lost: 2
limits['WS_tran/GC/nn_ang_norm/99.50'] = {'max': 63.32973255041167, 'min': 1.8493853486851997} # lost: 1
limits['WS_tran/GC/nn_ang_norm/99.90'] = {'max': 63.773141601139727, 'min': 1.8493853486851997} # lost: 0
limits['WS_tran/GC/nn_ang_norm/99.99'] = {'max': 63.773141601139727, 'min': 1.8493853486851997} # lost: 0
limits['WS_tran/GC/rot_ang/100.00'] = {'max2': -88.735967525115484, 'min1': 219.72831217043725, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GC/rot_ang/95.00'] = {'max': 267.1692135965464, 'min': 229.54782137308783} # lost: 10
limits['WS_tran/GC/rot_ang/99.00'] = {'max2': -88.854063790056273, 'min1': 220.02566602025615, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['WS_tran/GC/rot_ang/99.50'] = {'max2': -88.854063790056273, 'min1': 219.72831217043725, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['WS_tran/GC/rot_ang/99.90'] = {'max2': -88.735967525115484, 'min1': 219.72831217043725, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GC/rot_ang/99.99'] = {'max2': -88.735967525115484, 'min1': 219.72831217043725, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GG/dist/100.00'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['WS_tran/GG/dist/95.00'] = {'max': 7.4130729929790089, 'min': 6.1704593736455733} # lost: 5
limits['WS_tran/GG/dist/99.00'] = {'max': 7.4498901232218389, 'min': 6.1427157257067533} # lost: 1
limits['WS_tran/GG/dist/99.50'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['WS_tran/GG/dist/99.90'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['WS_tran/GG/dist/99.99'] = {'max': 7.4733446012185825, 'min': 6.1427157257067533} # lost: 0
limits['WS_tran/GG/min_dist/100.00'] = {'max': 2.4103640639981712, 'min': 1.0740620880252625} # lost: 0
limits['WS_tran/GG/min_dist/95.00'] = {'max': 2.245706929448843, 'min': 1.0748699679333218} # lost: 5
limits['WS_tran/GG/min_dist/99.00'] = {'max': 2.2836592968501765, 'min': 1.0740620880252625} # lost: 1
limits['WS_tran/GG/min_dist/99.50'] = {'max': 2.4103640639981712, 'min': 1.0740620880252625} # lost: 0
limits['WS_tran/GG/min_dist/99.90'] = {'max': 2.4103640639981712, 'min': 1.0740620880252625} # lost: 0
limits['WS_tran/GG/min_dist/99.99'] = {'max': 2.4103640639981712, 'min': 1.0740620880252625} # lost: 0
limits['WS_tran/GG/n2_z/100.00'] = {'max': 0.99974638, 'min': 0.46798351} # lost: 0
limits['WS_tran/GG/n2_z/95.00'] = {'max': 0.99974638, 'min': 0.58348656} # lost: 5
limits['WS_tran/GG/n2_z/99.00'] = {'max': 0.99974638, 'min': 0.46814522} # lost: 1
limits['WS_tran/GG/n2_z/99.50'] = {'max': 0.99974638, 'min': 0.46798351} # lost: 0
limits['WS_tran/GG/n2_z/99.90'] = {'max': 0.99974638, 'min': 0.46798351} # lost: 0
limits['WS_tran/GG/n2_z/99.99'] = {'max': 0.99974638, 'min': 0.46798351} # lost: 0
limits['WS_tran/GG/nn_ang_norm/100.00'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['WS_tran/GG/nn_ang_norm/95.00'] = {'max': 54.609025565314845, 'min': 0.94626027730738449} # lost: 5
limits['WS_tran/GG/nn_ang_norm/99.00'] = {'max': 62.058887062871584, 'min': 0.94626027730738449} # lost: 1
limits['WS_tran/GG/nn_ang_norm/99.50'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['WS_tran/GG/nn_ang_norm/99.90'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['WS_tran/GG/nn_ang_norm/99.99'] = {'max': 62.082580989102361, 'min': 0.94626027730738449} # lost: 0
limits['WS_tran/GG/rot_ang/100.00'] = {'max2': -74.526229834124308, 'min1': 222.51312296889088, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GG/rot_ang/95.00'] = {'max2': -75.980155247034816, 'min1': 222.52293322692381, 'min2': -90.0, 'max1': 270.0} # lost: 5
limits['WS_tran/GG/rot_ang/99.00'] = {'max2': -74.842003045406557, 'min1': 222.51312296889088, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['WS_tran/GG/rot_ang/99.50'] = {'max2': -74.526229834124308, 'min1': 222.51312296889088, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GG/rot_ang/99.90'] = {'max2': -74.526229834124308, 'min1': 222.51312296889088, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GG/rot_ang/99.99'] = {'max2': -74.526229834124308, 'min1': 222.51312296889088, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GU/dist/100.00'] = {'max': 7.9162433888552126, 'min': 5.8699416056232456} # lost: 0
limits['WS_tran/GU/dist/95.00'] = {'max': 7.3627870413827292, 'min': 6.1911469950632991} # lost: 50
limits['WS_tran/GU/dist/99.00'] = {'max': 7.6470481562781947, 'min': 5.9211297753757721} # lost: 10
limits['WS_tran/GU/dist/99.50'] = {'max': 7.6475923144539184, 'min': 5.8796351162705784} # lost: 5
limits['WS_tran/GU/dist/99.90'] = {'max': 7.6599429726959327, 'min': 5.8699416056232456} # lost: 1
limits['WS_tran/GU/dist/99.99'] = {'max': 7.9162433888552126, 'min': 5.8699416056232456} # lost: 0
limits['WS_tran/GU/min_dist/100.00'] = {'max': 2.5775813566838184, 'min': 1.0344311125107739} # lost: 0
limits['WS_tran/GU/min_dist/95.00'] = {'max': 2.4275156195988523, 'min': 1.5273002507777413} # lost: 50
limits['WS_tran/GU/min_dist/99.00'] = {'max': 2.513303950110112, 'min': 1.3787941946239661} # lost: 10
limits['WS_tran/GU/min_dist/99.50'] = {'max': 2.5215386527889168, 'min': 1.2446325299818652} # lost: 5
limits['WS_tran/GU/min_dist/99.90'] = {'max': 2.5332442354467686, 'min': 1.0344311125107739} # lost: 1
limits['WS_tran/GU/min_dist/99.99'] = {'max': 2.5775813566838184, 'min': 1.0344311125107739} # lost: 0
limits['WS_tran/GU/n2_z/100.00'] = {'max': 0.99998772, 'min': 0.4933688} # lost: 0
limits['WS_tran/GU/n2_z/95.00'] = {'max': 0.99998772, 'min': 0.84273058} # lost: 50
limits['WS_tran/GU/n2_z/99.00'] = {'max': 0.99998772, 'min': 0.74869609} # lost: 10
limits['WS_tran/GU/n2_z/99.50'] = {'max': 0.99998772, 'min': 0.7270804} # lost: 5
limits['WS_tran/GU/n2_z/99.90'] = {'max': 0.99998772, 'min': 0.64553607} # lost: 1
limits['WS_tran/GU/n2_z/99.99'] = {'max': 0.99998772, 'min': 0.4933688} # lost: 0
limits['WS_tran/GU/nn_ang_norm/100.00'] = {'max': 62.826006099123227, 'min': 0.54643887918055645} # lost: 0
limits['WS_tran/GU/nn_ang_norm/95.00'] = {'max': 33.00820397550185, 'min': 0.54643887918055645} # lost: 50
limits['WS_tran/GU/nn_ang_norm/99.00'] = {'max': 42.64555308306565, 'min': 0.54643887918055645} # lost: 10
limits['WS_tran/GU/nn_ang_norm/99.50'] = {'max': 43.559237733622005, 'min': 0.54643887918055645} # lost: 5
limits['WS_tran/GU/nn_ang_norm/99.90'] = {'max': 47.137078651076862, 'min': 0.54643887918055645} # lost: 1
limits['WS_tran/GU/nn_ang_norm/99.99'] = {'max': 62.826006099123227, 'min': 0.54643887918055645} # lost: 0
limits['WS_tran/GU/rot_ang/100.00'] = {'max2': -79.870177889996057, 'min1': 222.66104134925391, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/GU/rot_ang/95.00'] = {'max': 268.37023716921237, 'min': 237.58188795845473} # lost: 50
limits['WS_tran/GU/rot_ang/99.00'] = {'max2': -87.103876374411698, 'min1': 235.29135133681467, 'min2': -90.0, 'max1': 270.0} # lost: 10
limits['WS_tran/GU/rot_ang/99.50'] = {'max2': -85.165111895745099, 'min1': 233.69589409112791, 'min2': -90.0, 'max1': 270.0} # lost: 5
limits['WS_tran/GU/rot_ang/99.90'] = {'max2': -83.104580777287083, 'min1': 222.66104134925391, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['WS_tran/GU/rot_ang/99.99'] = {'max2': -79.870177889996057, 'min1': 222.66104134925391, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UA/dist/100.00'] = {'max': 6.095428449029721, 'min': 5.1484045838449441} # lost: 0
limits['WS_tran/UA/dist/95.00'] = {'max': 5.9610839556889852, 'min': 5.3347074203533404} # lost: 26
limits['WS_tran/UA/dist/99.00'] = {'max': 6.0440259097048212, 'min': 5.1913455952812271} # lost: 5
limits['WS_tran/UA/dist/99.50'] = {'max': 6.0916702765156154, 'min': 5.1764616062167068} # lost: 2
limits['WS_tran/UA/dist/99.90'] = {'max': 6.095428449029721, 'min': 5.1484045838449441} # lost: 0
limits['WS_tran/UA/dist/99.99'] = {'max': 6.095428449029721, 'min': 5.1484045838449441} # lost: 0
limits['WS_tran/UA/min_dist/100.00'] = {'max': 2.6012224464989488, 'min': 1.5446665032087403} # lost: 0
limits['WS_tran/UA/min_dist/95.00'] = {'max': 2.3424324788223725, 'min': 1.7185071480831471} # lost: 26
limits['WS_tran/UA/min_dist/99.00'] = {'max': 2.4371288645833586, 'min': 1.6574003109903286} # lost: 5
limits['WS_tran/UA/min_dist/99.50'] = {'max': 2.5589039207857915, 'min': 1.579312846314288} # lost: 2
limits['WS_tran/UA/min_dist/99.90'] = {'max': 2.6012224464989488, 'min': 1.5446665032087403} # lost: 0
limits['WS_tran/UA/min_dist/99.99'] = {'max': 2.6012224464989488, 'min': 1.5446665032087403} # lost: 0
limits['WS_tran/UA/n2_z/100.00'] = {'max': 0.99511802, 'min': 0.54501384} # lost: 0
limits['WS_tran/UA/n2_z/95.00'] = {'max': 0.99511802, 'min': 0.79524237} # lost: 26
limits['WS_tran/UA/n2_z/99.00'] = {'max': 0.99511802, 'min': 0.69419312} # lost: 5
limits['WS_tran/UA/n2_z/99.50'] = {'max': 0.99511802, 'min': 0.65380591} # lost: 2
limits['WS_tran/UA/n2_z/99.90'] = {'max': 0.99511802, 'min': 0.54501384} # lost: 0
limits['WS_tran/UA/n2_z/99.99'] = {'max': 0.99511802, 'min': 0.54501384} # lost: 0
limits['WS_tran/UA/nn_ang_norm/100.00'] = {'max': 57.11079749979087, 'min': 5.8840986869392644} # lost: 0
limits['WS_tran/UA/nn_ang_norm/95.00'] = {'max': 36.149117691750988, 'min': 5.8840986869392644} # lost: 26
limits['WS_tran/UA/nn_ang_norm/99.00'] = {'max': 45.863367899179963, 'min': 5.8840986869392644} # lost: 5
limits['WS_tran/UA/nn_ang_norm/99.50'] = {'max': 52.965125390592419, 'min': 5.8840986869392644} # lost: 2
limits['WS_tran/UA/nn_ang_norm/99.90'] = {'max': 57.11079749979087, 'min': 5.8840986869392644} # lost: 0
limits['WS_tran/UA/nn_ang_norm/99.99'] = {'max': 57.11079749979087, 'min': 5.8840986869392644} # lost: 0
limits['WS_tran/UA/rot_ang/100.00'] = {'max2': -81.110005832373133, 'min1': 233.03948994806848, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UA/rot_ang/95.00'] = {'max': 265.17179895319805, 'min': 244.47495509802184} # lost: 26
limits['WS_tran/UA/rot_ang/99.00'] = {'max': 267.54764709960267, 'min': 235.4006737972513} # lost: 5
limits['WS_tran/UA/rot_ang/99.50'] = {'max': 268.90669524712791, 'min': 234.71048900269113} # lost: 2
limits['WS_tran/UA/rot_ang/99.90'] = {'max2': -81.110005832373133, 'min1': 233.03948994806848, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UA/rot_ang/99.99'] = {'max2': -81.110005832373133, 'min1': 233.03948994806848, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UC/dist/100.00'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['WS_tran/UC/dist/95.00'] = {'max': 6.8431867255486836, 'min': 6.2424137095969101} # lost: 1
limits['WS_tran/UC/dist/99.00'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['WS_tran/UC/dist/99.50'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['WS_tran/UC/dist/99.90'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['WS_tran/UC/dist/99.99'] = {'max': 6.9366589949699495, 'min': 6.2424137095969101} # lost: 0
limits['WS_tran/UC/min_dist/100.00'] = {'max': 2.307795363379697, 'min': 1.5489762899918911} # lost: 0
limits['WS_tran/UC/min_dist/95.00'] = {'max': 2.2636134470401013, 'min': 1.5489762899918911} # lost: 1
limits['WS_tran/UC/min_dist/99.00'] = {'max': 2.307795363379697, 'min': 1.5489762899918911} # lost: 0
limits['WS_tran/UC/min_dist/99.50'] = {'max': 2.307795363379697, 'min': 1.5489762899918911} # lost: 0
limits['WS_tran/UC/min_dist/99.90'] = {'max': 2.307795363379697, 'min': 1.5489762899918911} # lost: 0
limits['WS_tran/UC/min_dist/99.99'] = {'max': 2.307795363379697, 'min': 1.5489762899918911} # lost: 0
limits['WS_tran/UC/n2_z/100.00'] = {'max': 0.9346422, 'min': 0.69916922} # lost: 0
limits['WS_tran/UC/n2_z/95.00'] = {'max': 0.9346422, 'min': 0.72050077} # lost: 1
limits['WS_tran/UC/n2_z/99.00'] = {'max': 0.9346422, 'min': 0.69916922} # lost: 0
limits['WS_tran/UC/n2_z/99.50'] = {'max': 0.9346422, 'min': 0.69916922} # lost: 0
limits['WS_tran/UC/n2_z/99.90'] = {'max': 0.9346422, 'min': 0.69916922} # lost: 0
limits['WS_tran/UC/n2_z/99.99'] = {'max': 0.9346422, 'min': 0.69916922} # lost: 0
limits['WS_tran/UC/nn_ang_norm/100.00'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['WS_tran/UC/nn_ang_norm/95.00'] = {'max': 44.081825752303438, 'min': 20.823474345279259} # lost: 1
limits['WS_tran/UC/nn_ang_norm/99.00'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['WS_tran/UC/nn_ang_norm/99.50'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['WS_tran/UC/nn_ang_norm/99.90'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['WS_tran/UC/nn_ang_norm/99.99'] = {'max': 44.168562324573429, 'min': 20.823474345279259} # lost: 0
limits['WS_tran/UC/rot_ang/100.00'] = {'max': 247.70572688551817, 'min': 215.70497123352658} # lost: 0
limits['WS_tran/UC/rot_ang/95.00'] = {'max': 247.51092290731992, 'min': 215.70497123352658} # lost: 1
limits['WS_tran/UC/rot_ang/99.00'] = {'max': 247.70572688551817, 'min': 215.70497123352658} # lost: 0
limits['WS_tran/UC/rot_ang/99.50'] = {'max': 247.70572688551817, 'min': 215.70497123352658} # lost: 0
limits['WS_tran/UC/rot_ang/99.90'] = {'max': 247.70572688551817, 'min': 215.70497123352658} # lost: 0
limits['WS_tran/UC/rot_ang/99.99'] = {'max': 247.70572688551817, 'min': 215.70497123352658} # lost: 0
limits['WS_tran/UG/dist/100.00'] = {'max': 7.5438836789803192, 'min': 5.3433248951412811} # lost: 0
limits['WS_tran/UG/dist/95.00'] = {'max': 7.2935428747480753, 'min': 5.4845148945435973} # lost: 10
limits['WS_tran/UG/dist/99.00'] = {'max': 7.3189378308807296, 'min': 5.3517511093982888} # lost: 2
limits['WS_tran/UG/dist/99.50'] = {'max': 7.3189378308807296, 'min': 5.3433248951412811} # lost: 1
limits['WS_tran/UG/dist/99.90'] = {'max': 7.5438836789803192, 'min': 5.3433248951412811} # lost: 0
limits['WS_tran/UG/dist/99.99'] = {'max': 7.5438836789803192, 'min': 5.3433248951412811} # lost: 0
limits['WS_tran/UG/min_dist/100.00'] = {'max': 2.3387547695581086, 'min': 1.1188727803145129} # lost: 0
limits['WS_tran/UG/min_dist/95.00'] = {'max': 2.2851591569728522, 'min': 1.5022011550068506} # lost: 10
limits['WS_tran/UG/min_dist/99.00'] = {'max': 2.3131796730767062, 'min': 1.2896700208067255} # lost: 2
limits['WS_tran/UG/min_dist/99.50'] = {'max': 2.3131796730767062, 'min': 1.1188727803145129} # lost: 1
limits['WS_tran/UG/min_dist/99.90'] = {'max': 2.3387547695581086, 'min': 1.1188727803145129} # lost: 0
limits['WS_tran/UG/min_dist/99.99'] = {'max': 2.3387547695581086, 'min': 1.1188727803145129} # lost: 0
limits['WS_tran/UG/n2_z/100.00'] = {'max': 0.9900316, 'min': 0.44066179} # lost: 0
limits['WS_tran/UG/n2_z/95.00'] = {'max': 0.9900316, 'min': 0.56671286} # lost: 10
limits['WS_tran/UG/n2_z/99.00'] = {'max': 0.9900316, 'min': 0.52600855} # lost: 2
limits['WS_tran/UG/n2_z/99.50'] = {'max': 0.9900316, 'min': 0.5240441} # lost: 1
limits['WS_tran/UG/n2_z/99.90'] = {'max': 0.9900316, 'min': 0.44066179} # lost: 0
limits['WS_tran/UG/n2_z/99.99'] = {'max': 0.9900316, 'min': 0.44066179} # lost: 0
limits['WS_tran/UG/nn_ang_norm/100.00'] = {'max': 59.323129922903846, 'min': 9.0213830114181874} # lost: 0
limits['WS_tran/UG/nn_ang_norm/95.00'] = {'max': 54.825364977085826, 'min': 9.0213830114181874} # lost: 10
limits['WS_tran/UG/nn_ang_norm/99.00'] = {'max': 58.289742792048429, 'min': 9.0213830114181874} # lost: 2
limits['WS_tran/UG/nn_ang_norm/99.50'] = {'max': 58.436182047853499, 'min': 9.0213830114181874} # lost: 1
limits['WS_tran/UG/nn_ang_norm/99.90'] = {'max': 59.323129922903846, 'min': 9.0213830114181874} # lost: 0
limits['WS_tran/UG/nn_ang_norm/99.99'] = {'max': 59.323129922903846, 'min': 9.0213830114181874} # lost: 0
limits['WS_tran/UG/rot_ang/100.00'] = {'max2': -63.489653067460722, 'min1': 214.58930233723689, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UG/rot_ang/95.00'] = {'max2': -79.142590786761616, 'min1': 219.72576089994143, 'min2': -90.0, 'max1': 270.0} # lost: 10
limits['WS_tran/UG/rot_ang/99.00'] = {'max2': -66.953413655836016, 'min1': 218.81289715233333, 'min2': -90.0, 'max1': 270.0} # lost: 2
limits['WS_tran/UG/rot_ang/99.50'] = {'max2': -66.953413655836016, 'min1': 214.58930233723689, 'min2': -90.0, 'max1': 270.0} # lost: 1
limits['WS_tran/UG/rot_ang/99.90'] = {'max2': -63.489653067460722, 'min1': 214.58930233723689, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UG/rot_ang/99.99'] = {'max2': -63.489653067460722, 'min1': 214.58930233723689, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UU/dist/100.00'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['WS_tran/UU/dist/95.00'] = {'max': 6.8654424108094059, 'min': 6.4226963798501044} # lost: 1
limits['WS_tran/UU/dist/99.00'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['WS_tran/UU/dist/99.50'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['WS_tran/UU/dist/99.90'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['WS_tran/UU/dist/99.99'] = {'max': 7.0045724267897702, 'min': 6.4226963798501044} # lost: 0
limits['WS_tran/UU/min_dist/100.00'] = {'max': 2.2688318371984728, 'min': 1.7317062482492311} # lost: 0
limits['WS_tran/UU/min_dist/95.00'] = {'max': 2.263057220811123, 'min': 1.7317062482492311} # lost: 1
limits['WS_tran/UU/min_dist/99.00'] = {'max': 2.2688318371984728, 'min': 1.7317062482492311} # lost: 0
limits['WS_tran/UU/min_dist/99.50'] = {'max': 2.2688318371984728, 'min': 1.7317062482492311} # lost: 0
limits['WS_tran/UU/min_dist/99.90'] = {'max': 2.2688318371984728, 'min': 1.7317062482492311} # lost: 0
limits['WS_tran/UU/min_dist/99.99'] = {'max': 2.2688318371984728, 'min': 1.7317062482492311} # lost: 0
limits['WS_tran/UU/n2_z/100.00'] = {'max': 0.98977393, 'min': 0.55735695} # lost: 0
limits['WS_tran/UU/n2_z/95.00'] = {'max': 0.98977393, 'min': 0.60424739} # lost: 1
limits['WS_tran/UU/n2_z/99.00'] = {'max': 0.98977393, 'min': 0.55735695} # lost: 0
limits['WS_tran/UU/n2_z/99.50'] = {'max': 0.98977393, 'min': 0.55735695} # lost: 0
limits['WS_tran/UU/n2_z/99.90'] = {'max': 0.98977393, 'min': 0.55735695} # lost: 0
limits['WS_tran/UU/n2_z/99.99'] = {'max': 0.98977393, 'min': 0.55735695} # lost: 0
limits['WS_tran/UU/nn_ang_norm/100.00'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['WS_tran/UU/nn_ang_norm/95.00'] = {'max': 53.748974975216008, 'min': 7.6395401196762283} # lost: 1
limits['WS_tran/UU/nn_ang_norm/99.00'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['WS_tran/UU/nn_ang_norm/99.50'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['WS_tran/UU/nn_ang_norm/99.90'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['WS_tran/UU/nn_ang_norm/99.99'] = {'max': 59.383167285708261, 'min': 7.6395401196762283} # lost: 0
limits['WS_tran/UU/rot_ang/100.00'] = {'max2': -82.335253814604869, 'min1': 212.60122397880829, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UU/rot_ang/95.00'] = {'max': 265.22930587566276, 'min': 212.60122397880829} # lost: 1
limits['WS_tran/UU/rot_ang/99.00'] = {'max2': -82.335253814604869, 'min1': 212.60122397880829, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UU/rot_ang/99.50'] = {'max2': -82.335253814604869, 'min1': 212.60122397880829, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UU/rot_ang/99.90'] = {'max2': -82.335253814604869, 'min1': 212.60122397880829, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WS_tran/UU/rot_ang/99.99'] = {'max2': -82.335253814604869, 'min1': 212.60122397880829, 'min2': -90.0, 'max1': 270.0} # lost: 0
limits['WW_cis/AA/dist/100.00'] = {'max': 6.7714644791029883, 'min': 4.2273894426925649} # lost: 0
limits['WW_cis/AA/dist/95.00'] = {'max': 6.4514988623996903, 'min': 5.1429869926953069} # lost: 75
limits['WW_cis/AA/dist/99.00'] = {'max': 6.5202521493459136, 'min': 4.7192924611049465} # lost: 15
limits['WW_cis/AA/dist/99.50'] = {'max': 6.567058205563904, 'min': 4.6521957168940133} # lost: 7
limits['WW_cis/AA/dist/99.90'] = {'max': 6.7714644791029883, 'min': 4.2273894426925649} # lost: 1
limits['WW_cis/AA/dist/99.99'] = {'max': 6.7714644791029883, 'min': 4.2273894426925649} # lost: 0
limits['WW_cis/AA/min_dist/100.00'] = {'max': 2.5274240390139671, 'min': 0.18838903682192845} # lost: 0
limits['WW_cis/AA/min_dist/95.00'] = {'max': 2.3649255656315922, 'min': 1.5872967986674302} # lost: 75
limits['WW_cis/AA/min_dist/99.00'] = {'max': 2.4363399457094399, 'min': 1.2744560787686094} # lost: 15
limits['WW_cis/AA/min_dist/99.50'] = {'max': 2.4429257549605232, 'min': 1.071982826055959} # lost: 7
limits['WW_cis/AA/min_dist/99.90'] = {'max': 2.5274199116228711, 'min': 0.18838903682192845} # lost: 1
limits['WW_cis/AA/min_dist/99.99'] = {'max': 2.5274240390139671, 'min': 0.18838903682192845} # lost: 0
limits['WW_cis/AA/n2_z/100.00'] = {'max': -0.45921785, 'min': -0.99954236} # lost: 0
limits['WW_cis/AA/n2_z/95.00'] = {'max': -0.65702254, 'min': -0.99954236} # lost: 75
limits['WW_cis/AA/n2_z/99.00'] = {'max': -0.54687446, 'min': -0.99954236} # lost: 15
limits['WW_cis/AA/n2_z/99.50'] = {'max': -0.51990718, 'min': -0.99954236} # lost: 7
limits['WW_cis/AA/n2_z/99.90'] = {'max': -0.45921791, 'min': -0.99954236} # lost: 1
limits['WW_cis/AA/n2_z/99.99'] = {'max': -0.45921785, 'min': -0.99954236} # lost: 0
limits['WW_cis/AA/nn_ang_norm/100.00'] = {'max': 60.510621603045934, 'min': 1.7391114178906548} # lost: 0
limits['WW_cis/AA/nn_ang_norm/95.00'] = {'max': 49.144558446741058, 'min': 1.7391114178906548} # lost: 75
limits['WW_cis/AA/nn_ang_norm/99.00'] = {'max': 56.156348686406119, 'min': 1.7391114178906548} # lost: 15
limits['WW_cis/AA/nn_ang_norm/99.50'] = {'max': 57.851683600673326, 'min': 1.7391114178906548} # lost: 7
limits['WW_cis/AA/nn_ang_norm/99.90'] = {'max': 60.510621603045934, 'min': 1.7391114178906548} # lost: 1
limits['WW_cis/AA/nn_ang_norm/99.99'] = {'max': 60.510621603045934, 'min': 1.7391114178906548} # lost: 0
limits['WW_cis/AA/rot_ang/100.00'] = {'max': 141.36682060221787, 'min': 45.329762539160477} # lost: 0
limits['WW_cis/AA/rot_ang/95.00'] = {'max': 105.50071157859546, 'min': 53.366791570781395} # lost: 75
limits['WW_cis/AA/rot_ang/99.00'] = {'max': 118.55864088701303, 'min': 48.904289613879023} # lost: 15
limits['WW_cis/AA/rot_ang/99.50'] = {'max': 125.14870722954082, 'min': 47.187284614382605} # lost: 7
limits['WW_cis/AA/rot_ang/99.90'] = {'max': 141.36682060221787, 'min': 45.329762539160477} # lost: 1
limits['WW_cis/AA/rot_ang/99.99'] = {'max': 141.36682060221787, 'min': 45.329762539160477} # lost: 0
limits['WW_cis/AC/dist/100.00'] = {'max': 8.0160299335977996, 'min': 4.7292460574918325} # lost: 0
limits['WW_cis/AC/dist/95.00'] = {'max': 7.512963951274565, 'min': 5.4053546465309621} # lost: 112
limits['WW_cis/AC/dist/99.00'] = {'max': 7.7209819782075302, 'min': 5.0260784456486105} # lost: 22
limits['WW_cis/AC/dist/99.50'] = {'max': 7.8734022118778233, 'min': 4.9468246055663716} # lost: 11
limits['WW_cis/AC/dist/99.90'] = {'max': 8.0112112588414757, 'min': 4.8218729791056809} # lost: 2
limits['WW_cis/AC/dist/99.99'] = {'max': 8.0160299335977996, 'min': 4.7292460574918325} # lost: 0
limits['WW_cis/AC/min_dist/100.00'] = {'max': 3.0142423583674089, 'min': 0.99419095982361438} # lost: 0
limits['WW_cis/AC/min_dist/95.00'] = {'max': 2.4878203593034067, 'min': 1.4176849685646158} # lost: 112
limits['WW_cis/AC/min_dist/99.00'] = {'max': 2.7416981968883491, 'min': 1.1651636087770867} # lost: 22
limits['WW_cis/AC/min_dist/99.50'] = {'max': 2.7942221975388923, 'min': 1.0397473608468129} # lost: 11
limits['WW_cis/AC/min_dist/99.90'] = {'max': 2.9514232015176183, 'min': 0.99860261793773686} # lost: 2
limits['WW_cis/AC/min_dist/99.99'] = {'max': 3.0142423583674089, 'min': 0.99419095982361438} # lost: 0
limits['WW_cis/AC/n2_z/100.00'] = {'max': -0.44465047, 'min': -0.99999171} # lost: 0
limits['WW_cis/AC/n2_z/95.00'] = {'max': -0.72612113, 'min': -0.99999171} # lost: 112
limits['WW_cis/AC/n2_z/99.00'] = {'max': -0.63191432, 'min': -0.99999171} # lost: 22
limits['WW_cis/AC/n2_z/99.50'] = {'max': -0.58722472, 'min': -0.99999171} # lost: 11
limits['WW_cis/AC/n2_z/99.90'] = {'max': -0.51425564, 'min': -0.99999171} # lost: 2
limits['WW_cis/AC/n2_z/99.99'] = {'max': -0.44465047, 'min': -0.99999171} # lost: 0
limits['WW_cis/AC/nn_ang_norm/100.00'] = {'max': 63.446674040424298, 'min': 0.16070934221406219} # lost: 0
limits['WW_cis/AC/nn_ang_norm/95.00'] = {'max': 43.361368974599571, 'min': 0.16070934221406219} # lost: 112
limits['WW_cis/AC/nn_ang_norm/99.00'] = {'max': 50.05432598380844, 'min': 0.16070934221406219} # lost: 22
limits['WW_cis/AC/nn_ang_norm/99.50'] = {'max': 52.518576274078995, 'min': 0.16070934221406219} # lost: 11
limits['WW_cis/AC/nn_ang_norm/99.90'] = {'max': 58.946235075546213, 'min': 0.16070934221406219} # lost: 2
limits['WW_cis/AC/nn_ang_norm/99.99'] = {'max': 63.446674040424298, 'min': 0.16070934221406219} # lost: 0
limits['WW_cis/AC/rot_ang/100.00'] = {'max': 123.13672156749745, 'min': 35.206300343965019} # lost: 0
limits['WW_cis/AC/rot_ang/95.00'] = {'max': 100.01852007790168, 'min': 51.061725093274767} # lost: 112
limits['WW_cis/AC/rot_ang/99.00'] = {'max': 110.40534129350948, 'min': 44.886962481301701} # lost: 22
limits['WW_cis/AC/rot_ang/99.50'] = {'max': 112.02338182107836, 'min': 39.635079455889475} # lost: 11
limits['WW_cis/AC/rot_ang/99.90'] = {'max': 117.98823183768688, 'min': 35.541691192789827} # lost: 2
limits['WW_cis/AC/rot_ang/99.99'] = {'max': 123.13672156749745, 'min': 35.206300343965019} # lost: 0
limits['WW_cis/AG/dist/100.00'] = {'max': 6.8616396839784661, 'min': 4.0889611201949858} # lost: 0
limits['WW_cis/AG/dist/95.00'] = {'max': 6.0526014740410119, 'min': 5.0782341223523728} # lost: 280
limits['WW_cis/AG/dist/99.00'] = {'max': 6.2953980080167353, 'min': 4.8673011186900643} # lost: 56
limits['WW_cis/AG/dist/99.50'] = {'max': 6.4562646280164602, 'min': 4.7157115968585099} # lost: 28
limits['WW_cis/AG/dist/99.90'] = {'max': 6.6473791673649556, 'min': 4.401220553789428} # lost: 5
limits['WW_cis/AG/dist/99.99'] = {'max': 6.8616396839784661, 'min': 4.0889611201949858} # lost: 0
limits['WW_cis/AG/min_dist/100.00'] = {'max': 2.7226842911232452, 'min': 0.20996931254873882} # lost: 0
limits['WW_cis/AG/min_dist/95.00'] = {'max': 2.2790295247008938, 'min': 1.2494667323812516} # lost: 280
limits['WW_cis/AG/min_dist/99.00'] = {'max': 2.4404186696031873, 'min': 0.97554005039623337} # lost: 56
limits['WW_cis/AG/min_dist/99.50'] = {'max': 2.4891037866879486, 'min': 0.8546791588817515} # lost: 28
limits['WW_cis/AG/min_dist/99.90'] = {'max': 2.5670038874261443, 'min': 0.56541532610649736} # lost: 5
limits['WW_cis/AG/min_dist/99.99'] = {'max': 2.7226842911232452, 'min': 0.20996931254873882} # lost: 0
limits['WW_cis/AG/n2_z/100.00'] = {'max': -0.44589281, 'min': -0.99996543} # lost: 0
limits['WW_cis/AG/n2_z/95.00'] = {'max': -0.72818345, 'min': -0.99996543} # lost: 280
limits['WW_cis/AG/n2_z/99.00'] = {'max': -0.62507665, 'min': -0.99996543} # lost: 56
limits['WW_cis/AG/n2_z/99.50'] = {'max': -0.58091849, 'min': -0.99996543} # lost: 28
limits['WW_cis/AG/n2_z/99.90'] = {'max': -0.47945547, 'min': -0.99996543} # lost: 5
limits['WW_cis/AG/n2_z/99.99'] = {'max': -0.44589281, 'min': -0.99996543} # lost: 0
limits['WW_cis/AG/nn_ang_norm/100.00'] = {'max': 63.368263468752545, 'min': 0.34263826094652927} # lost: 0
limits['WW_cis/AG/nn_ang_norm/95.00'] = {'max': 43.373253503755393, 'min': 0.34263826094652927} # lost: 280
limits['WW_cis/AG/nn_ang_norm/99.00'] = {'max': 51.5223112213626, 'min': 0.34263826094652927} # lost: 56
limits['WW_cis/AG/nn_ang_norm/99.50'] = {'max': 53.96831124617087, 'min': 0.34263826094652927} # lost: 28
limits['WW_cis/AG/nn_ang_norm/99.90'] = {'max': 60.320182268607638, 'min': 0.34263826094652927} # lost: 5
limits['WW_cis/AG/nn_ang_norm/99.99'] = {'max': 63.368263468752545, 'min': 0.34263826094652927} # lost: 0
limits['WW_cis/AG/rot_ang/100.00'] = {'max': 148.66715990741355, 'min': -64.18063819816679} # lost: 0
limits['WW_cis/AG/rot_ang/95.00'] = {'max': 108.24848862739336, 'min': 68.038151698243723} # lost: 280
limits['WW_cis/AG/rot_ang/99.00'] = {'max': 115.59864833903882, 'min': 56.209287116436272} # lost: 56
limits['WW_cis/AG/rot_ang/99.50'] = {'max': 118.08589342816566, 'min': 53.325749645248592} # lost: 28
limits['WW_cis/AG/rot_ang/99.90'] = {'max': 127.73642671442798, 'min': 46.411101579219839} # lost: 5
limits['WW_cis/AG/rot_ang/99.99'] = {'max': 148.66715990741355, 'min': -64.18063819816679} # lost: 0
limits['WW_cis/AU/dist/100.00'] = {'max': 7.4520579209184223, 'min': 4.0157897467835308} # lost: 0
limits['WW_cis/AU/dist/95.00'] = {'max': 5.9533318688744821, 'min': 5.2103520038906304} # lost: 3684
limits['WW_cis/AU/dist/99.00'] = {'max': 6.3434161960045365, 'min': 5.0630143854248635} # lost: 736
limits['WW_cis/AU/dist/99.50'] = {'max': 6.9806792076839619, 'min': 4.9940819127131375} # lost: 368
limits['WW_cis/AU/dist/99.90'] = {'max': 7.3165477028706452, 'min': 4.8398852853679752} # lost: 73
limits['WW_cis/AU/dist/99.99'] = {'max': 7.4251271463226303, 'min': 4.493116191190035} # lost: 7
limits['WW_cis/AU/min_dist/100.00'] = {'max': 2.9455165706432491, 'min': 0.72059995135575627} # lost: 0
limits['WW_cis/AU/min_dist/95.00'] = {'max': 2.2865768656660603, 'min': 1.5527981318969311} # lost: 3684
limits['WW_cis/AU/min_dist/99.00'] = {'max': 2.4719047518430299, 'min': 1.3435393841688632} # lost: 736
limits['WW_cis/AU/min_dist/99.50'] = {'max': 2.528698881058999, 'min': 1.2486970603896481} # lost: 368
limits['WW_cis/AU/min_dist/99.90'] = {'max': 2.6789370789184646, 'min': 1.0310236798349885} # lost: 73
limits['WW_cis/AU/min_dist/99.99'] = {'max': 2.8218705062824556, 'min': 0.80755061059000932} # lost: 7
limits['WW_cis/AU/n2_z/100.00'] = {'max': -0.42038047, 'min': -0.99999994} # lost: 0
limits['WW_cis/AU/n2_z/95.00'] = {'max': -0.85239482, 'min': -0.99999994} # lost: 3684
limits['WW_cis/AU/n2_z/99.00'] = {'max': -0.72338802, 'min': -0.99999994} # lost: 736
limits['WW_cis/AU/n2_z/99.50'] = {'max': -0.6559673, 'min': -0.99999994} # lost: 368
limits['WW_cis/AU/n2_z/99.90'] = {'max': -0.52153248, 'min': -0.99999994} # lost: 73
limits['WW_cis/AU/n2_z/99.99'] = {'max': -0.44139627, 'min': -0.99999994} # lost: 7
limits['WW_cis/AU/nn_ang_norm/100.00'] = {'max': 64.893144182092911, 'min': 0.0} # lost: 0
limits['WW_cis/AU/nn_ang_norm/95.00'] = {'max': 31.686936437646978, 'min': 0.0} # lost: 3684
limits['WW_cis/AU/nn_ang_norm/99.00'] = {'max': 43.7457037191962, 'min': 0.0} # lost: 736
limits['WW_cis/AU/nn_ang_norm/99.50'] = {'max': 49.292432042271855, 'min': 0.0} # lost: 368
limits['WW_cis/AU/nn_ang_norm/99.90'] = {'max': 59.040491686092381, 'min': 0.0} # lost: 73
limits['WW_cis/AU/nn_ang_norm/99.99'] = {'max': 63.902930676981143, 'min': 0.0} # lost: 7
limits['WW_cis/AU/rot_ang/100.00'] = {'max': 131.62370517118543, 'min': 22.394840387663361} # lost: 0
limits['WW_cis/AU/rot_ang/95.00'] = {'max': 85.059431208069327, 'min': 57.281743491824741} # lost: 3684
limits['WW_cis/AU/rot_ang/99.00'] = {'max': 94.670808205343008, 'min': 50.374823623217011} # lost: 736
limits['WW_cis/AU/rot_ang/99.50'] = {'max': 99.363915930496646, 'min': 47.117064001961026} # lost: 368
limits['WW_cis/AU/rot_ang/99.90'] = {'max': 113.87207470341581, 'min': 39.201400007406882} # lost: 73
limits['WW_cis/AU/rot_ang/99.99'] = {'max': 127.61540919961332, 'min': 26.140585873283083} # lost: 7
limits['WW_cis/CA/dist/100.00'] = {'max': 8.0160299335977996, 'min': 4.7292460574918325} # lost: 0
limits['WW_cis/CA/dist/95.00'] = {'max': 7.512963951274565, 'min': 5.4053546465309621} # lost: 112
limits['WW_cis/CA/dist/99.00'] = {'max': 7.7209819782075302, 'min': 5.0260784456486105} # lost: 22
limits['WW_cis/CA/dist/99.50'] = {'max': 7.8734022118778233, 'min': 4.9468246055663716} # lost: 11
limits['WW_cis/CA/dist/99.90'] = {'max': 8.0112112588414757, 'min': 4.8218729791056809} # lost: 2
limits['WW_cis/CA/dist/99.99'] = {'max': 8.0160299335977996, 'min': 4.7292460574918325} # lost: 0
limits['WW_cis/CA/min_dist/100.00'] = {'max': 3.0142488467565665, 'min': 0.99418653474924912} # lost: 0
limits['WW_cis/CA/min_dist/95.00'] = {'max': 2.487834981864347, 'min': 1.4176849451497533} # lost: 112
limits['WW_cis/CA/min_dist/99.00'] = {'max': 2.7416963446658822, 'min': 1.1651642371143585} # lost: 22
limits['WW_cis/CA/min_dist/99.50'] = {'max': 2.7942212507196991, 'min': 1.0397433679936607} # lost: 11
limits['WW_cis/CA/min_dist/99.90'] = {'max': 2.9514424380017417, 'min': 0.99859269303218878} # lost: 2
limits['WW_cis/CA/min_dist/99.99'] = {'max': 3.0142488467565665, 'min': 0.99418653474924912} # lost: 0
limits['WW_cis/CA/n2_z/100.00'] = {'max': -0.44465047, 'min': -0.99999171} # lost: 0
limits['WW_cis/CA/n2_z/95.00'] = {'max': -0.72612125, 'min': -0.99999171} # lost: 112
limits['WW_cis/CA/n2_z/99.00'] = {'max': -0.63191426, 'min': -0.99999171} # lost: 22
limits['WW_cis/CA/n2_z/99.50'] = {'max': -0.58722472, 'min': -0.99999171} # lost: 11
limits['WW_cis/CA/n2_z/99.90'] = {'max': -0.51425582, 'min': -0.99999171} # lost: 2
limits['WW_cis/CA/n2_z/99.99'] = {'max': -0.44465047, 'min': -0.99999171} # lost: 0
limits['WW_cis/CA/nn_ang_norm/100.00'] = {'max': 63.446674040424298, 'min': 0.16070934221406219} # lost: 0
limits['WW_cis/CA/nn_ang_norm/95.00'] = {'max': 43.361368974599571, 'min': 0.16070934221406219} # lost: 112
limits['WW_cis/CA/nn_ang_norm/99.00'] = {'max': 50.05432598380844, 'min': 0.16070934221406219} # lost: 22
limits['WW_cis/CA/nn_ang_norm/99.50'] = {'max': 52.518576274078995, 'min': 0.16070934221406219} # lost: 11
limits['WW_cis/CA/nn_ang_norm/99.90'] = {'max': 58.946235075546213, 'min': 0.16070934221406219} # lost: 2
limits['WW_cis/CA/nn_ang_norm/99.99'] = {'max': 63.446674040424298, 'min': 0.16070934221406219} # lost: 0
limits['WW_cis/CA/rot_ang/100.00'] = {'max': 123.13672156749745, 'min': 35.206300343965019} # lost: 0
limits['WW_cis/CA/rot_ang/95.00'] = {'max': 100.01852007790168, 'min': 51.061725093274767} # lost: 112
limits['WW_cis/CA/rot_ang/99.00'] = {'max': 110.40534129350948, 'min': 44.886962481301701} # lost: 22
limits['WW_cis/CA/rot_ang/99.50'] = {'max': 112.02338182107836, 'min': 39.635079455889475} # lost: 11
limits['WW_cis/CA/rot_ang/99.90'] = {'max': 117.98823183768688, 'min': 35.541691192789827} # lost: 2
limits['WW_cis/CA/rot_ang/99.99'] = {'max': 123.13672156749745, 'min': 35.206300343965019} # lost: 0
limits['WW_cis/CC/dist/100.00'] = {'max': 7.6801252243335165, 'min': 5.0127991666844745} # lost: 0
limits['WW_cis/CC/dist/95.00'] = {'max': 7.3851581126084396, 'min': 5.4714723289589848} # lost: 120
limits['WW_cis/CC/dist/99.00'] = {'max': 7.5515450825445978, 'min': 5.3371546500268456} # lost: 24
limits['WW_cis/CC/dist/99.50'] = {'max': 7.5748415699856233, 'min': 5.2460047804671435} # lost: 12
limits['WW_cis/CC/dist/99.90'] = {'max': 7.6801252243335165, 'min': 5.0127991666844745} # lost: 2
limits['WW_cis/CC/dist/99.99'] = {'max': 7.6801252243335165, 'min': 5.0127991666844745} # lost: 0
limits['WW_cis/CC/min_dist/100.00'] = {'max': 2.9780357067850218, 'min': 1.2125895062826355} # lost: 0
limits['WW_cis/CC/min_dist/95.00'] = {'max': 2.540423642661457, 'min': 1.5471525769629784} # lost: 120
limits['WW_cis/CC/min_dist/99.00'] = {'max': 2.6703457223298899, 'min': 1.3274906958965123} # lost: 24
limits['WW_cis/CC/min_dist/99.50'] = {'max': 2.8009649602954272, 'min': 1.3119656601286482} # lost: 12
limits['WW_cis/CC/min_dist/99.90'] = {'max': 2.9780283047554752, 'min': 1.2125992075020176} # lost: 2
limits['WW_cis/CC/min_dist/99.99'] = {'max': 2.9780357067850218, 'min': 1.2125895062826355} # lost: 0
limits['WW_cis/CC/n2_z/100.00'] = {'max': -0.44410908, 'min': -0.99999976} # lost: 0
limits['WW_cis/CC/n2_z/95.00'] = {'max': -0.80816066, 'min': -0.99999976} # lost: 120
limits['WW_cis/CC/n2_z/99.00'] = {'max': -0.62498283, 'min': -0.99999976} # lost: 24
limits['WW_cis/CC/n2_z/99.50'] = {'max': -0.56531739, 'min': -0.99999976} # lost: 12
limits['WW_cis/CC/n2_z/99.90'] = {'max': -0.48753613, 'min': -0.99999976} # lost: 2
limits['WW_cis/CC/n2_z/99.99'] = {'max': -0.44410908, 'min': -0.99999976} # lost: 0
limits['WW_cis/CC/nn_ang_norm/100.00'] = {'max': 63.388685734370881, 'min': 0.11869001844013383} # lost: 0
limits['WW_cis/CC/nn_ang_norm/95.00'] = {'max': 35.399786289330905, 'min': 0.11869001844013383} # lost: 120
limits['WW_cis/CC/nn_ang_norm/99.00'] = {'max': 51.639025493899766, 'min': 0.11869001844013383} # lost: 24
limits['WW_cis/CC/nn_ang_norm/99.50'] = {'max': 54.897899992209616, 'min': 0.11869001844013383} # lost: 12
limits['WW_cis/CC/nn_ang_norm/99.90'] = {'max': 60.093638554216653, 'min': 0.11869001844013383} # lost: 2
limits['WW_cis/CC/nn_ang_norm/99.99'] = {'max': 63.388685734370881, 'min': 0.11869001844013383} # lost: 0
limits['WW_cis/CC/rot_ang/100.00'] = {'max': 115.43346838356933, 'min': 31.126898814556341} # lost: 0
limits['WW_cis/CC/rot_ang/95.00'] = {'max': 90.950158580319055, 'min': 36.574840455289461} # lost: 120
limits['WW_cis/CC/rot_ang/99.00'] = {'max': 94.178478745568441, 'min': 33.139442862066275} # lost: 24
limits['WW_cis/CC/rot_ang/99.50'] = {'max': 97.956020533239681, 'min': 32.431633786277615} # lost: 12
limits['WW_cis/CC/rot_ang/99.90'] = {'max': 115.43346838356933, 'min': 31.126898814556341} # lost: 2
limits['WW_cis/CC/rot_ang/99.99'] = {'max': 115.43346838356933, 'min': 31.126898814556341} # lost: 0
limits['WW_cis/CG/dist/100.00'] = {'max': 6.9682556250319356, 'min': 4.2393451273334595} # lost: 0
limits['WW_cis/CG/dist/95.00'] = {'max': 6.0297400531961802, 'min': 5.2856683510185061} # lost: 12453
limits['WW_cis/CG/dist/99.00'] = {'max': 6.3029293647503035, 'min': 5.145013473572015} # lost: 2490
limits['WW_cis/CG/dist/99.50'] = {'max': 6.4205572808910976, 'min': 5.0707942983675736} # lost: 1245
limits['WW_cis/CG/dist/99.90'] = {'max': 6.6401517373552803, 'min': 4.9213797710740455} # lost: 249
limits['WW_cis/CG/dist/99.99'] = {'max': 6.821087139000241, 'min': 4.5921019717441149} # lost: 24
limits['WW_cis/CG/min_dist/100.00'] = {'max': 3.0080405990607475, 'min': 0.064906633204350112} # lost: 0
limits['WW_cis/CG/min_dist/95.00'] = {'max': 2.2133431324159081, 'min': 1.4359188412764541} # lost: 12453
limits['WW_cis/CG/min_dist/99.00'] = {'max': 2.4219481067385864, 'min': 1.1420390828301408} # lost: 2490
limits['WW_cis/CG/min_dist/99.50'] = {'max': 2.4920877117845159, 'min': 0.99661083861154687} # lost: 1245
limits['WW_cis/CG/min_dist/99.90'] = {'max': 2.6505176662788741, 'min': 0.66106061824325435} # lost: 249
limits['WW_cis/CG/min_dist/99.99'] = {'max': 2.8867724640275445, 'min': 0.35184893031529402} # lost: 24
limits['WW_cis/CG/n2_z/100.00'] = {'max': -0.42344943, 'min': -1.0} # lost: 0
limits['WW_cis/CG/n2_z/95.00'] = {'max': -0.84003162, 'min': -1.0} # lost: 12453
limits['WW_cis/CG/n2_z/99.00'] = {'max': -0.71479321, 'min': -1.0} # lost: 2490
limits['WW_cis/CG/n2_z/99.50'] = {'max': -0.65595597, 'min': -1.0} # lost: 1245
limits['WW_cis/CG/n2_z/99.90'] = {'max': -0.53344679, 'min': -1.0} # lost: 249
limits['WW_cis/CG/n2_z/99.99'] = {'max': -0.44533604, 'min': -1.0} # lost: 24
limits['WW_cis/CG/nn_ang_norm/100.00'] = {'max': 64.993370377973676, 'min': 0.0} # lost: 0
limits['WW_cis/CG/nn_ang_norm/95.00'] = {'max': 32.98102505893263, 'min': 0.0} # lost: 12453
limits['WW_cis/CG/nn_ang_norm/99.00'] = {'max': 44.528825888673168, 'min': 0.0} # lost: 2490
limits['WW_cis/CG/nn_ang_norm/99.50'] = {'max': 49.292090532813347, 'min': 0.0} # lost: 1245
limits['WW_cis/CG/nn_ang_norm/99.90'] = {'max': 58.152020678857127, 'min': 0.0} # lost: 249
limits['WW_cis/CG/nn_ang_norm/99.99'] = {'max': 63.862618900499726, 'min': 0.0} # lost: 24
limits['WW_cis/CG/rot_ang/100.00'] = {'max': 118.99095667172938, 'min': -58.183507974493708} # lost: 0
limits['WW_cis/CG/rot_ang/95.00'] = {'max': 82.019415704628599, 'min': 58.933030128680159} # lost: 12453
limits['WW_cis/CG/rot_ang/99.00'] = {'max': 89.22412098971698, 'min': 52.524632278610873} # lost: 2490
limits['WW_cis/CG/rot_ang/99.50'] = {'max': 92.181667116624382, 'min': 49.933402474046851} # lost: 1245
limits['WW_cis/CG/rot_ang/99.90'] = {'max': 99.688204262446916, 'min': 44.578865349688165} # lost: 249
limits['WW_cis/CG/rot_ang/99.99'] = {'max': 108.90628533224718, 'min': 35.122010562757097} # lost: 24
limits['WW_cis/CU/dist/100.00'] = {'max': 7.6123844528707547, 'min': 5.0488255113167702} # lost: 0
limits['WW_cis/CU/dist/95.00'] = {'max': 7.4310155006602026, 'min': 5.3099655376507267} # lost: 79
limits['WW_cis/CU/dist/99.00'] = {'max': 7.5418079015503308, 'min': 5.112348631609775} # lost: 15
limits['WW_cis/CU/dist/99.50'] = {'max': 7.5669065653154561, 'min': 5.0558467714381345} # lost: 7
limits['WW_cis/CU/dist/99.90'] = {'max': 7.5916220895294355, 'min': 5.0488255113167702} # lost: 1
limits['WW_cis/CU/dist/99.99'] = {'max': 7.6123844528707547, 'min': 5.0488255113167702} # lost: 0
limits['WW_cis/CU/min_dist/100.00'] = {'max': 2.6054338342860062, 'min': 1.0826299323448787} # lost: 0
limits['WW_cis/CU/min_dist/95.00'] = {'max': 2.4497642695329933, 'min': 1.5745562064374972} # lost: 79
limits['WW_cis/CU/min_dist/99.00'] = {'max': 2.5285778263038163, 'min': 1.3914009111363952} # lost: 15
limits['WW_cis/CU/min_dist/99.50'] = {'max': 2.5412238181860274, 'min': 1.2969887992949454} # lost: 7
limits['WW_cis/CU/min_dist/99.90'] = {'max': 2.5584576955836908, 'min': 1.0826299323448787} # lost: 1
limits['WW_cis/CU/min_dist/99.99'] = {'max': 2.6054338342860062, 'min': 1.0826299323448787} # lost: 0
limits['WW_cis/CU/n2_z/100.00'] = {'max': -0.41999811, 'min': -0.99995017} # lost: 0
limits['WW_cis/CU/n2_z/95.00'] = {'max': -0.75289261, 'min': -0.99995017} # lost: 79
limits['WW_cis/CU/n2_z/99.00'] = {'max': -0.60738355, 'min': -0.99995017} # lost: 15
limits['WW_cis/CU/n2_z/99.50'] = {'max': -0.56974447, 'min': -0.99995017} # lost: 7
limits['WW_cis/CU/n2_z/99.90'] = {'max': -0.45901284, 'min': -0.99995017} # lost: 1
limits['WW_cis/CU/n2_z/99.99'] = {'max': -0.41999811, 'min': -0.99995017} # lost: 0
limits['WW_cis/CU/nn_ang_norm/100.00'] = {'max': 61.82056992358433, 'min': 0.59446733564490728} # lost: 0
limits['WW_cis/CU/nn_ang_norm/95.00'] = {'max': 41.68227625017866, 'min': 0.59446733564490728} # lost: 79
limits['WW_cis/CU/nn_ang_norm/99.00'] = {'max': 52.530761331558296, 'min': 0.59446733564490728} # lost: 15
limits['WW_cis/CU/nn_ang_norm/99.50'] = {'max': 55.693535068246064, 'min': 0.59446733564490728} # lost: 7
limits['WW_cis/CU/nn_ang_norm/99.90'] = {'max': 60.973681108016109, 'min': 0.59446733564490728} # lost: 1
limits['WW_cis/CU/nn_ang_norm/99.99'] = {'max': 61.82056992358433, 'min': 0.59446733564490728} # lost: 0
limits['WW_cis/CU/rot_ang/100.00'] = {'max': 114.64916193410222, 'min': 26.950208503732494} # lost: 0
limits['WW_cis/CU/rot_ang/95.00'] = {'max': 101.95458636475844, 'min': 44.849024363236381} # lost: 79
limits['WW_cis/CU/rot_ang/99.00'] = {'max': 109.54480280562908, 'min': 34.389425271578006} # lost: 15
limits['WW_cis/CU/rot_ang/99.50'] = {'max': 111.61649693843175, 'min': 26.977431864350653} # lost: 7
limits['WW_cis/CU/rot_ang/99.90'] = {'max': 114.31029413155679, 'min': 26.950208503732494} # lost: 1
limits['WW_cis/CU/rot_ang/99.99'] = {'max': 114.64916193410222, 'min': 26.950208503732494} # lost: 0
limits['WW_cis/GA/dist/100.00'] = {'max': 6.8616396839784661, 'min': 4.0889611201949858} # lost: 0
limits['WW_cis/GA/dist/95.00'] = {'max': 6.0526014740410119, 'min': 5.0782341223523728} # lost: 280
limits['WW_cis/GA/dist/99.00'] = {'max': 6.2953980080167353, 'min': 4.8673011186900643} # lost: 56
limits['WW_cis/GA/dist/99.50'] = {'max': 6.4562646280164602, 'min': 4.7157115968585099} # lost: 28
limits['WW_cis/GA/dist/99.90'] = {'max': 6.6473791673649556, 'min': 4.401220553789428} # lost: 5
limits['WW_cis/GA/dist/99.99'] = {'max': 6.8616396839784661, 'min': 4.0889611201949858} # lost: 0
limits['WW_cis/GA/min_dist/100.00'] = {'max': 2.7226689007019802, 'min': 0.20997504618882309} # lost: 0
limits['WW_cis/GA/min_dist/95.00'] = {'max': 2.2790368702931652, 'min': 1.2494586126511802} # lost: 280
limits['WW_cis/GA/min_dist/99.00'] = {'max': 2.4404296256554661, 'min': 0.97553462559204807} # lost: 56
limits['WW_cis/GA/min_dist/99.50'] = {'max': 2.4890963005936619, 'min': 0.85467539084984789} # lost: 28
limits['WW_cis/GA/min_dist/99.90'] = {'max': 2.5670246934736638, 'min': 0.5654156062209752} # lost: 5
limits['WW_cis/GA/min_dist/99.99'] = {'max': 2.7226689007019802, 'min': 0.20997504618882309} # lost: 0
limits['WW_cis/GA/n2_z/100.00'] = {'max': -0.44589272, 'min': -0.99996543} # lost: 0
limits['WW_cis/GA/n2_z/95.00'] = {'max': -0.72818333, 'min': -0.99996543} # lost: 280
limits['WW_cis/GA/n2_z/99.00'] = {'max': -0.62507671, 'min': -0.99996543} # lost: 56
limits['WW_cis/GA/n2_z/99.50'] = {'max': -0.58091867, 'min': -0.99996543} # lost: 28
limits['WW_cis/GA/n2_z/99.90'] = {'max': -0.47945586, 'min': -0.99996543} # lost: 5
limits['WW_cis/GA/n2_z/99.99'] = {'max': -0.44589272, 'min': -0.99996543} # lost: 0
limits['WW_cis/GA/nn_ang_norm/100.00'] = {'max': 63.368263468752545, 'min': 0.34263826094652927} # lost: 0
limits['WW_cis/GA/nn_ang_norm/95.00'] = {'max': 43.373253503755393, 'min': 0.34263826094652927} # lost: 280
limits['WW_cis/GA/nn_ang_norm/99.00'] = {'max': 51.5223112213626, 'min': 0.34263826094652927} # lost: 56
limits['WW_cis/GA/nn_ang_norm/99.50'] = {'max': 53.96831124617087, 'min': 0.34263826094652927} # lost: 28
limits['WW_cis/GA/nn_ang_norm/99.90'] = {'max': 60.320182268607638, 'min': 0.34263826094652927} # lost: 5
limits['WW_cis/GA/nn_ang_norm/99.99'] = {'max': 63.368263468752545, 'min': 0.34263826094652927} # lost: 0
limits['WW_cis/GA/rot_ang/100.00'] = {'max': 148.66715990741355, 'min': -64.18063819816679} # lost: 0
limits['WW_cis/GA/rot_ang/95.00'] = {'max': 108.24848862739336, 'min': 68.038151698243723} # lost: 280
limits['WW_cis/GA/rot_ang/99.00'] = {'max': 115.59864833903882, 'min': 56.209287116436272} # lost: 56
limits['WW_cis/GA/rot_ang/99.50'] = {'max': 118.08589342816566, 'min': 53.325749645248592} # lost: 28
limits['WW_cis/GA/rot_ang/99.90'] = {'max': 127.73642671442798, 'min': 46.411101579219839} # lost: 5
limits['WW_cis/GA/rot_ang/99.99'] = {'max': 148.66715990741355, 'min': -64.18063819816679} # lost: 0
limits['WW_cis/GC/dist/100.00'] = {'max': 6.9682556250319356, 'min': 4.2393451273334595} # lost: 0
limits['WW_cis/GC/dist/95.00'] = {'max': 6.0297400531961802, 'min': 5.2856683510185061} # lost: 12453
limits['WW_cis/GC/dist/99.00'] = {'max': 6.3029293647503035, 'min': 5.145013473572015} # lost: 2490
limits['WW_cis/GC/dist/99.50'] = {'max': 6.4205572808910976, 'min': 5.0707942983675736} # lost: 1245
limits['WW_cis/GC/dist/99.90'] = {'max': 6.6401517373552803, 'min': 4.9213797710740455} # lost: 249
limits['WW_cis/GC/dist/99.99'] = {'max': 6.821087139000241, 'min': 4.5921019717441149} # lost: 24
limits['WW_cis/GC/min_dist/100.00'] = {'max': 3.008018835187638, 'min': 0.064925734314260811} # lost: 0
limits['WW_cis/GC/min_dist/95.00'] = {'max': 2.2133416032259361, 'min': 1.4359131462544883} # lost: 12453
limits['WW_cis/GC/min_dist/99.00'] = {'max': 2.4219388572501592, 'min': 1.1420362104979649} # lost: 2490
limits['WW_cis/GC/min_dist/99.50'] = {'max': 2.4920897494213716, 'min': 0.99662032456901328} # lost: 1245
limits['WW_cis/GC/min_dist/99.90'] = {'max': 2.6505324544560742, 'min': 0.66104519082668811} # lost: 249
limits['WW_cis/GC/min_dist/99.99'] = {'max': 2.8867755558783128, 'min': 0.35184310374582334} # lost: 24
limits['WW_cis/GC/n2_z/100.00'] = {'max': -0.42344937, 'min': -1.0} # lost: 0
limits['WW_cis/GC/n2_z/95.00'] = {'max': -0.84003162, 'min': -1.0} # lost: 12453
limits['WW_cis/GC/n2_z/99.00'] = {'max': -0.71479321, 'min': -1.0} # lost: 2490
limits['WW_cis/GC/n2_z/99.50'] = {'max': -0.65595597, 'min': -1.0} # lost: 1245
limits['WW_cis/GC/n2_z/99.90'] = {'max': -0.53344673, 'min': -1.0} # lost: 249
limits['WW_cis/GC/n2_z/99.99'] = {'max': -0.44533592, 'min': -1.0} # lost: 24
limits['WW_cis/GC/nn_ang_norm/100.00'] = {'max': 64.993370377973676, 'min': 0.0} # lost: 0
limits['WW_cis/GC/nn_ang_norm/95.00'] = {'max': 32.98102505893263, 'min': 0.0} # lost: 12453
limits['WW_cis/GC/nn_ang_norm/99.00'] = {'max': 44.528825888673168, 'min': 0.0} # lost: 2490
limits['WW_cis/GC/nn_ang_norm/99.50'] = {'max': 49.292090532813347, 'min': 0.0} # lost: 1245
limits['WW_cis/GC/nn_ang_norm/99.90'] = {'max': 58.152020678857127, 'min': 0.0} # lost: 249
limits['WW_cis/GC/nn_ang_norm/99.99'] = {'max': 63.862618900499726, 'min': 0.0} # lost: 24
limits['WW_cis/GC/rot_ang/100.00'] = {'max': 118.99095667172938, 'min': -58.183507974493708} # lost: 0
limits['WW_cis/GC/rot_ang/95.00'] = {'max': 82.019415704628599, 'min': 58.933030128680159} # lost: 12453
limits['WW_cis/GC/rot_ang/99.00'] = {'max': 89.22412098971698, 'min': 52.524632278610873} # lost: 2490
limits['WW_cis/GC/rot_ang/99.50'] = {'max': 92.181667116624382, 'min': 49.933402474046851} # lost: 1245
limits['WW_cis/GC/rot_ang/99.90'] = {'max': 99.688204262446916, 'min': 44.578865349688165} # lost: 249
limits['WW_cis/GC/rot_ang/99.99'] = {'max': 108.90628533224718, 'min': 35.122010562757097} # lost: 24
limits['WW_cis/GG/dist/100.00'] = {'max': 7.2861494352902021, 'min': 4.78381960600829} # lost: 0
limits['WW_cis/GG/dist/95.00'] = {'max': 7.0749026081254209, 'min': 5.2458047895828903} # lost: 35
limits['WW_cis/GG/dist/99.00'] = {'max': 7.1350395709176526, 'min': 4.9037761011714744} # lost: 7
limits['WW_cis/GG/dist/99.50'] = {'max': 7.1411539057562559, 'min': 4.78381960600829} # lost: 3
limits['WW_cis/GG/dist/99.90'] = {'max': 7.2861494352902021, 'min': 4.78381960600829} # lost: 0
limits['WW_cis/GG/dist/99.99'] = {'max': 7.2861494352902021, 'min': 4.78381960600829} # lost: 0
limits['WW_cis/GG/min_dist/100.00'] = {'max': 2.3329930218469483, 'min': 0.55023938511989712} # lost: 0
limits['WW_cis/GG/min_dist/95.00'] = {'max': 2.0375679479212212, 'min': 0.75423866178817989} # lost: 35
limits['WW_cis/GG/min_dist/99.00'] = {'max': 2.3134998561913398, 'min': 0.60894787715022758} # lost: 7
limits['WW_cis/GG/min_dist/99.50'] = {'max': 2.330366814439607, 'min': 0.55025116092461923} # lost: 3
limits['WW_cis/GG/min_dist/99.90'] = {'max': 2.3329930218469483, 'min': 0.55023938511989712} # lost: 0
limits['WW_cis/GG/min_dist/99.99'] = {'max': 2.3329930218469483, 'min': 0.55023938511989712} # lost: 0
limits['WW_cis/GG/n2_z/100.00'] = {'max': -0.44247612, 'min': -0.99987811} # lost: 0
limits['WW_cis/GG/n2_z/95.00'] = {'max': -0.65592468, 'min': -0.99987811} # lost: 35
limits['WW_cis/GG/n2_z/99.00'] = {'max': -0.52503878, 'min': -0.99987811} # lost: 7
limits['WW_cis/GG/n2_z/99.50'] = {'max': -0.50587434, 'min': -0.99987811} # lost: 3
limits['WW_cis/GG/n2_z/99.90'] = {'max': -0.44247612, 'min': -0.99987811} # lost: 0
limits['WW_cis/GG/n2_z/99.99'] = {'max': -0.44247612, 'min': -0.99987811} # lost: 0
limits['WW_cis/GG/nn_ang_norm/100.00'] = {'max': 63.842210295259733, 'min': 0.83486267367266009} # lost: 0
limits['WW_cis/GG/nn_ang_norm/95.00'] = {'max': 49.060383195409827, 'min': 0.83486267367266009} # lost: 35
limits['WW_cis/GG/nn_ang_norm/99.00'] = {'max': 58.413534961798575, 'min': 0.83486267367266009} # lost: 7
limits['WW_cis/GG/nn_ang_norm/99.50'] = {'max': 62.706459119313337, 'min': 0.83486267367266009} # lost: 3
limits['WW_cis/GG/nn_ang_norm/99.90'] = {'max': 63.842210295259733, 'min': 0.83486267367266009} # lost: 0
limits['WW_cis/GG/nn_ang_norm/99.99'] = {'max': 63.842210295259733, 'min': 0.83486267367266009} # lost: 0
limits['WW_cis/GG/rot_ang/100.00'] = {'max': 134.02493732843874, 'min': 42.250841569894924} # lost: 0
limits['WW_cis/GG/rot_ang/95.00'] = {'max': 125.97042149800032, 'min': 59.159238625909509} # lost: 35
limits['WW_cis/GG/rot_ang/99.00'] = {'max': 131.9993998645235, 'min': 48.781238431476602} # lost: 7
limits['WW_cis/GG/rot_ang/99.50'] = {'max': 132.13369585468246, 'min': 42.250841569894924} # lost: 3
limits['WW_cis/GG/rot_ang/99.90'] = {'max': 134.02493732843874, 'min': 42.250841569894924} # lost: 0
limits['WW_cis/GG/rot_ang/99.99'] = {'max': 134.02493732843874, 'min': 42.250841569894924} # lost: 0
limits['WW_cis/GU/dist/100.00'] = {'max': 7.4247143241179083, 'min': 4.7506002770376217} # lost: 0
limits['WW_cis/GU/dist/95.00'] = {'max': 6.4375112612096306, 'min': 5.4842318153299949} # lost: 1963
limits['WW_cis/GU/dist/99.00'] = {'max': 6.9391305997731605, 'min': 5.2682538799919669} # lost: 392
limits['WW_cis/GU/dist/99.50'] = {'max': 7.193797787881504, 'min': 5.18170332669707} # lost: 196
limits['WW_cis/GU/dist/99.90'] = {'max': 7.3288368497135057, 'min': 4.9451529027039198} # lost: 39
limits['WW_cis/GU/dist/99.99'] = {'max': 7.4154406798167392, 'min': 4.7747653976203521} # lost: 3
limits['WW_cis/GU/min_dist/100.00'] = {'max': 2.9700650556610886, 'min': 0.28407733357263698} # lost: 0
limits['WW_cis/GU/min_dist/95.00'] = {'max': 2.2128228486572423, 'min': 1.235115208718478} # lost: 1963
limits['WW_cis/GU/min_dist/99.00'] = {'max': 2.4013120298089827, 'min': 0.93800222322388482} # lost: 392
limits['WW_cis/GU/min_dist/99.50'] = {'max': 2.4780527638481846, 'min': 0.86489251910340514} # lost: 196
limits['WW_cis/GU/min_dist/99.90'] = {'max': 2.6080170644517526, 'min': 0.63258390766180927} # lost: 39
limits['WW_cis/GU/min_dist/99.99'] = {'max': 2.8222460270304106, 'min': 0.28543260837692291} # lost: 3
limits['WW_cis/GU/n2_z/100.00'] = {'max': -0.43812951, 'min': -0.99999994} # lost: 0
limits['WW_cis/GU/n2_z/95.00'] = {'max': -0.86721981, 'min': -0.99999994} # lost: 1963
limits['WW_cis/GU/n2_z/99.00'] = {'max': -0.74435329, 'min': -0.99999994} # lost: 392
limits['WW_cis/GU/n2_z/99.50'] = {'max': -0.69460362, 'min': -0.99999994} # lost: 196
limits['WW_cis/GU/n2_z/99.90'] = {'max': -0.57472932, 'min': -0.99999994} # lost: 39
limits['WW_cis/GU/n2_z/99.99'] = {'max': -0.46297029, 'min': -0.99999994} # lost: 3
limits['WW_cis/GU/nn_ang_norm/100.00'] = {'max': 63.851813541232772, 'min': 0.062559523840974407} # lost: 0
limits['WW_cis/GU/nn_ang_norm/95.00'] = {'max': 30.136155646973918, 'min': 0.062559523840974407} # lost: 1963
limits['WW_cis/GU/nn_ang_norm/99.00'] = {'max': 42.434703549525608, 'min': 0.062559523840974407} # lost: 392
limits['WW_cis/GU/nn_ang_norm/99.50'] = {'max': 47.121784263663443, 'min': 0.062559523840974407} # lost: 196
limits['WW_cis/GU/nn_ang_norm/99.90'] = {'max': 55.321726890587243, 'min': 0.062559523840974407} # lost: 39
limits['WW_cis/GU/nn_ang_norm/99.99'] = {'max': 62.869782602746682, 'min': 0.062559523840974407} # lost: 3
limits['WW_cis/GU/rot_ang/100.00'] = {'max': 164.68051513467182, 'min': 25.207075346034099} # lost: 0
limits['WW_cis/GU/rot_ang/95.00'] = {'max': 85.901910269575865, 'min': 56.918440092267844} # lost: 1963
limits['WW_cis/GU/rot_ang/99.00'] = {'max': 93.559783171671143, 'min': 50.085372454666569} # lost: 392
limits['WW_cis/GU/rot_ang/99.50'] = {'max': 98.068849500271867, 'min': 47.154078648409715} # lost: 196
limits['WW_cis/GU/rot_ang/99.90'] = {'max': 111.62648119297181, 'min': 40.539123440695079} # lost: 39
limits['WW_cis/GU/rot_ang/99.99'] = {'max': 124.76197229464164, 'min': 29.044735262785217} # lost: 3
limits['WW_cis/UA/dist/100.00'] = {'max': 7.4520579209184223, 'min': 4.0157897467835308} # lost: 0
limits['WW_cis/UA/dist/95.00'] = {'max': 5.9533318688744821, 'min': 5.2103520038906304} # lost: 3684
limits['WW_cis/UA/dist/99.00'] = {'max': 6.3434161960045365, 'min': 5.0630143854248635} # lost: 736
limits['WW_cis/UA/dist/99.50'] = {'max': 6.9806792076839619, 'min': 4.9940819127131375} # lost: 368
limits['WW_cis/UA/dist/99.90'] = {'max': 7.3165477028706452, 'min': 4.8398852853679752} # lost: 73
limits['WW_cis/UA/dist/99.99'] = {'max': 7.4251271463226303, 'min': 4.493116191190035} # lost: 7
limits['WW_cis/UA/min_dist/100.00'] = {'max': 2.9455050071985212, 'min': 0.72071970931805862} # lost: 0
limits['WW_cis/UA/min_dist/95.00'] = {'max': 2.2865751057359223, 'min': 1.5527989229625654} # lost: 3684
limits['WW_cis/UA/min_dist/99.00'] = {'max': 2.4718888228876374, 'min': 1.3435417674007042} # lost: 736
limits['WW_cis/UA/min_dist/99.50'] = {'max': 2.5287155737014277, 'min': 1.2486764857101895} # lost: 368
limits['WW_cis/UA/min_dist/99.90'] = {'max': 2.6789299655893828, 'min': 1.0310337140777535} # lost: 73
limits['WW_cis/UA/min_dist/99.99'] = {'max': 2.8218821693297245, 'min': 0.8075343170571283} # lost: 7
limits['WW_cis/UA/n2_z/100.00'] = {'max': -0.42038041, 'min': -1.0} # lost: 0
limits['WW_cis/UA/n2_z/95.00'] = {'max': -0.85239482, 'min': -1.0} # lost: 3684
limits['WW_cis/UA/n2_z/99.00'] = {'max': -0.72338796, 'min': -1.0} # lost: 736
limits['WW_cis/UA/n2_z/99.50'] = {'max': -0.65596712, 'min': -1.0} # lost: 368
limits['WW_cis/UA/n2_z/99.90'] = {'max': -0.52153224, 'min': -1.0} # lost: 73
limits['WW_cis/UA/n2_z/99.99'] = {'max': -0.44139627, 'min': -1.0} # lost: 7
limits['WW_cis/UA/nn_ang_norm/100.00'] = {'max': 64.893144182092911, 'min': 0.0} # lost: 0
limits['WW_cis/UA/nn_ang_norm/95.00'] = {'max': 31.686936437646978, 'min': 0.0} # lost: 3684
limits['WW_cis/UA/nn_ang_norm/99.00'] = {'max': 43.7457037191962, 'min': 0.0} # lost: 736
limits['WW_cis/UA/nn_ang_norm/99.50'] = {'max': 49.292432042271855, 'min': 0.0} # lost: 368
limits['WW_cis/UA/nn_ang_norm/99.90'] = {'max': 59.040491686092381, 'min': 0.0} # lost: 73
limits['WW_cis/UA/nn_ang_norm/99.99'] = {'max': 63.902930676981143, 'min': 0.0} # lost: 7
limits['WW_cis/UA/rot_ang/100.00'] = {'max': 131.62370517118543, 'min': 22.394840387663361} # lost: 0
limits['WW_cis/UA/rot_ang/95.00'] = {'max': 85.059431208069327, 'min': 57.281743491824741} # lost: 3684
limits['WW_cis/UA/rot_ang/99.00'] = {'max': 94.670808205343008, 'min': 50.374823623217011} # lost: 736
limits['WW_cis/UA/rot_ang/99.50'] = {'max': 99.363915930496646, 'min': 47.117064001961026} # lost: 368
limits['WW_cis/UA/rot_ang/99.90'] = {'max': 113.87207470341581, 'min': 39.201400007406882} # lost: 73
limits['WW_cis/UA/rot_ang/99.99'] = {'max': 127.61540919961332, 'min': 26.140585873283083} # lost: 7
limits['WW_cis/UC/dist/100.00'] = {'max': 7.6123844528707547, 'min': 5.0488255113167702} # lost: 0
limits['WW_cis/UC/dist/95.00'] = {'max': 7.4310155006602026, 'min': 5.3099655376507267} # lost: 79
limits['WW_cis/UC/dist/99.00'] = {'max': 7.5418079015503308, 'min': 5.112348631609775} # lost: 15
limits['WW_cis/UC/dist/99.50'] = {'max': 7.5669065653154561, 'min': 5.0558467714381345} # lost: 7
limits['WW_cis/UC/dist/99.90'] = {'max': 7.5916220895294355, 'min': 5.0488255113167702} # lost: 1
limits['WW_cis/UC/dist/99.99'] = {'max': 7.6123844528707547, 'min': 5.0488255113167702} # lost: 0
limits['WW_cis/UC/min_dist/100.00'] = {'max': 2.605433023384808, 'min': 1.082634499403109} # lost: 0
limits['WW_cis/UC/min_dist/95.00'] = {'max': 2.4497498816757255, 'min': 1.5745635960055522} # lost: 79
limits['WW_cis/UC/min_dist/99.00'] = {'max': 2.5285832973141775, 'min': 1.3913980707855516} # lost: 15
limits['WW_cis/UC/min_dist/99.50'] = {'max': 2.5412227896528568, 'min': 1.2969888782664292} # lost: 7
limits['WW_cis/UC/min_dist/99.90'] = {'max': 2.5584567653944323, 'min': 1.082634499403109} # lost: 1
limits['WW_cis/UC/min_dist/99.99'] = {'max': 2.605433023384808, 'min': 1.082634499403109} # lost: 0
limits['WW_cis/UC/n2_z/100.00'] = {'max': -0.41999817, 'min': -0.99995023} # lost: 0
limits['WW_cis/UC/n2_z/95.00'] = {'max': -0.75289249, 'min': -0.99995023} # lost: 79
limits['WW_cis/UC/n2_z/99.00'] = {'max': -0.60738349, 'min': -0.99995023} # lost: 15
limits['WW_cis/UC/n2_z/99.50'] = {'max': -0.56974459, 'min': -0.99995023} # lost: 7
limits['WW_cis/UC/n2_z/99.90'] = {'max': -0.45901269, 'min': -0.99995023} # lost: 1
limits['WW_cis/UC/n2_z/99.99'] = {'max': -0.41999817, 'min': -0.99995023} # lost: 0
limits['WW_cis/UC/nn_ang_norm/100.00'] = {'max': 61.82056992358433, 'min': 0.59446733564490728} # lost: 0
limits['WW_cis/UC/nn_ang_norm/95.00'] = {'max': 41.68227625017866, 'min': 0.59446733564490728} # lost: 79
limits['WW_cis/UC/nn_ang_norm/99.00'] = {'max': 52.530761331558296, 'min': 0.59446733564490728} # lost: 15
limits['WW_cis/UC/nn_ang_norm/99.50'] = {'max': 55.693535068246064, 'min': 0.59446733564490728} # lost: 7
limits['WW_cis/UC/nn_ang_norm/99.90'] = {'max': 60.973681108016109, 'min': 0.59446733564490728} # lost: 1
limits['WW_cis/UC/nn_ang_norm/99.99'] = {'max': 61.82056992358433, 'min': 0.59446733564490728} # lost: 0
limits['WW_cis/UC/rot_ang/100.00'] = {'max': 114.64916193410222, 'min': 26.950208503732494} # lost: 0
limits['WW_cis/UC/rot_ang/95.00'] = {'max': 101.95458636475844, 'min': 44.849024363236381} # lost: 79
limits['WW_cis/UC/rot_ang/99.00'] = {'max': 109.54480280562908, 'min': 34.389425271578006} # lost: 15
limits['WW_cis/UC/rot_ang/99.50'] = {'max': 111.61649693843175, 'min': 26.977431864350653} # lost: 7
limits['WW_cis/UC/rot_ang/99.90'] = {'max': 114.31029413155679, 'min': 26.950208503732494} # lost: 1
limits['WW_cis/UC/rot_ang/99.99'] = {'max': 114.64916193410222, 'min': 26.950208503732494} # lost: 0
limits['WW_cis/UG/dist/100.00'] = {'max': 7.4247143241179083, 'min': 4.7506002770376217} # lost: 0
limits['WW_cis/UG/dist/95.00'] = {'max': 6.4375112612096306, 'min': 5.4842318153299949} # lost: 1963
limits['WW_cis/UG/dist/99.00'] = {'max': 6.9391305997731605, 'min': 5.2682538799919669} # lost: 392
limits['WW_cis/UG/dist/99.50'] = {'max': 7.193797787881504, 'min': 5.18170332669707} # lost: 196
limits['WW_cis/UG/dist/99.90'] = {'max': 7.3288368497135057, 'min': 4.9451529027039198} # lost: 39
limits['WW_cis/UG/dist/99.99'] = {'max': 7.4154406798167392, 'min': 4.7747653976203521} # lost: 3
limits['WW_cis/UG/min_dist/100.00'] = {'max': 2.9700798231553351, 'min': 0.28406745101086006} # lost: 0
limits['WW_cis/UG/min_dist/95.00'] = {'max': 2.212824095361281, 'min': 1.2351170875326236} # lost: 1963
limits['WW_cis/UG/min_dist/99.00'] = {'max': 2.4013188540664974, 'min': 0.93800459439035611} # lost: 392
limits['WW_cis/UG/min_dist/99.50'] = {'max': 2.4780721157421643, 'min': 0.86489636786171931} # lost: 196
limits['WW_cis/UG/min_dist/99.90'] = {'max': 2.6080279665079869, 'min': 0.6325908694655723} # lost: 39
limits['WW_cis/UG/min_dist/99.99'] = {'max': 2.8222470137296036, 'min': 0.28543055674831463} # lost: 3
limits['WW_cis/UG/n2_z/100.00'] = {'max': -0.43812963, 'min': -1.0} # lost: 0
limits['WW_cis/UG/n2_z/95.00'] = {'max': -0.86721963, 'min': -1.0} # lost: 1963
limits['WW_cis/UG/n2_z/99.00'] = {'max': -0.74435329, 'min': -1.0} # lost: 392
limits['WW_cis/UG/n2_z/99.50'] = {'max': -0.69460362, 'min': -1.0} # lost: 196
limits['WW_cis/UG/n2_z/99.90'] = {'max': -0.57472938, 'min': -1.0} # lost: 39
limits['WW_cis/UG/n2_z/99.99'] = {'max': -0.46296987, 'min': -1.0} # lost: 3
limits['WW_cis/UG/nn_ang_norm/100.00'] = {'max': 63.851813541232772, 'min': 0.062559523840974407} # lost: 0
limits['WW_cis/UG/nn_ang_norm/95.00'] = {'max': 30.136155646973918, 'min': 0.062559523840974407} # lost: 1963
limits['WW_cis/UG/nn_ang_norm/99.00'] = {'max': 42.434703549525608, 'min': 0.062559523840974407} # lost: 392
limits['WW_cis/UG/nn_ang_norm/99.50'] = {'max': 47.121784263663443, 'min': 0.062559523840974407} # lost: 196
limits['WW_cis/UG/nn_ang_norm/99.90'] = {'max': 55.321726890587243, 'min': 0.062559523840974407} # lost: 39
limits['WW_cis/UG/nn_ang_norm/99.99'] = {'max': 62.869782602746682, 'min': 0.062559523840974407} # lost: 3
limits['WW_cis/UG/rot_ang/100.00'] = {'max': 164.68051513467182, 'min': 25.207075346034099} # lost: 0
limits['WW_cis/UG/rot_ang/95.00'] = {'max': 85.901910269575865, 'min': 56.918440092267844} # lost: 1963
limits['WW_cis/UG/rot_ang/99.00'] = {'max': 93.559783171671143, 'min': 50.085372454666569} # lost: 392
limits['WW_cis/UG/rot_ang/99.50'] = {'max': 98.068849500271867, 'min': 47.154078648409715} # lost: 196
limits['WW_cis/UG/rot_ang/99.90'] = {'max': 111.62648119297181, 'min': 40.539123440695079} # lost: 39
limits['WW_cis/UG/rot_ang/99.99'] = {'max': 124.76197229464164, 'min': 29.044735262785217} # lost: 3
limits['WW_cis/UU/dist/100.00'] = {'max': 6.9551571590206347, 'min': 5.0046062932700739} # lost: 0
limits['WW_cis/UU/dist/95.00'] = {'max': 6.5010587366104913, 'min': 5.5594068318929635} # lost: 382
limits['WW_cis/UU/dist/99.00'] = {'max': 6.7034952126333076, 'min': 5.3353887886973608} # lost: 76
limits['WW_cis/UU/dist/99.50'] = {'max': 6.746835125248678, 'min': 5.271595276029335} # lost: 38
limits['WW_cis/UU/dist/99.90'] = {'max': 6.901475846989725, 'min': 5.0155169622780971} # lost: 7
limits['WW_cis/UU/dist/99.99'] = {'max': 6.9551571590206347, 'min': 5.0046062932700739} # lost: 0
limits['WW_cis/UU/min_dist/100.00'] = {'max': 2.6343880937483197, 'min': 1.1242646090870816} # lost: 0
limits['WW_cis/UU/min_dist/95.00'] = {'max': 2.3116579512186655, 'min': 1.4917891565474182} # lost: 382
limits['WW_cis/UU/min_dist/99.00'] = {'max': 2.5163681059992222, 'min': 1.3004650428410856} # lost: 76
limits['WW_cis/UU/min_dist/99.50'] = {'max': 2.5349041632111295, 'min': 1.1910328047401657} # lost: 38
limits['WW_cis/UU/min_dist/99.90'] = {'max': 2.5571393053482869, 'min': 1.1307249500999952} # lost: 7
limits['WW_cis/UU/min_dist/99.99'] = {'max': 2.6343880937483197, 'min': 1.1242646090870816} # lost: 0
limits['WW_cis/UU/n2_z/100.00'] = {'max': -0.43441272, 'min': -0.99997985} # lost: 0
limits['WW_cis/UU/n2_z/95.00'] = {'max': -0.76366484, 'min': -0.99997985} # lost: 382
limits['WW_cis/UU/n2_z/99.00'] = {'max': -0.63459218, 'min': -0.99997985} # lost: 76
limits['WW_cis/UU/n2_z/99.50'] = {'max': -0.5708341, 'min': -0.99997985} # lost: 38
limits['WW_cis/UU/n2_z/99.90'] = {'max': -0.46698773, 'min': -0.99997985} # lost: 7
limits['WW_cis/UU/n2_z/99.99'] = {'max': -0.43441272, 'min': -0.99997985} # lost: 0
limits['WW_cis/UU/nn_ang_norm/100.00'] = {'max': 64.869047274701103, 'min': 0.13270556661700539} # lost: 0
limits['WW_cis/UU/nn_ang_norm/95.00'] = {'max': 40.114884439444126, 'min': 0.13270556661700539} # lost: 382
limits['WW_cis/UU/nn_ang_norm/99.00'] = {'max': 50.298778454203187, 'min': 0.13270556661700539} # lost: 76
limits['WW_cis/UU/nn_ang_norm/99.50'] = {'max': 54.583642988497331, 'min': 0.13270556661700539} # lost: 38
limits['WW_cis/UU/nn_ang_norm/99.90'] = {'max': 62.946827136584417, 'min': 0.13270556661700539} # lost: 7
limits['WW_cis/UU/nn_ang_norm/99.99'] = {'max': 64.869047274701103, 'min': 0.13270556661700539} # lost: 0
limits['WW_cis/UU/rot_ang/100.00'] = {'max': 106.81017642478805, 'min': 22.42635487887668} # lost: 0
limits['WW_cis/UU/rot_ang/95.00'] = {'max': 78.638311349425152, 'min': 46.510365404245846} # lost: 382
limits['WW_cis/UU/rot_ang/99.00'] = {'max': 89.166289798861158, 'min': 39.258383370408104} # lost: 76
limits['WW_cis/UU/rot_ang/99.50'] = {'max': 92.463172162832464, 'min': 37.499901703190396} # lost: 38
limits['WW_cis/UU/rot_ang/99.90'] = {'max': 99.846943115282031, 'min': 30.024223615990529} # lost: 7
limits['WW_cis/UU/rot_ang/99.99'] = {'max': 106.81017642478805, 'min': 22.42635487887668} # lost: 0
limits['WW_tran/AA/dist/100.00'] = {'max': 7.2245215980160156, 'min': 4.6530819711851796} # lost: 0
limits['WW_tran/AA/dist/95.00'] = {'max': 6.7098280035570079, 'min': 5.1673207712486793} # lost: 252
limits['WW_tran/AA/dist/99.00'] = {'max': 6.8645139760092722, 'min': 4.844363519188752} # lost: 50
limits['WW_tran/AA/dist/99.50'] = {'max': 6.9337487644566194, 'min': 4.7987137501415544} # lost: 25
limits['WW_tran/AA/dist/99.90'] = {'max': 7.0880547796352014, 'min': 4.7148212690619475} # lost: 5
limits['WW_tran/AA/dist/99.99'] = {'max': 7.2245215980160156, 'min': 4.6530819711851796} # lost: 0
limits['WW_tran/AA/min_dist/100.00'] = {'max': 2.8674624644393401, 'min': 0.88965504581188803} # lost: 0
limits['WW_tran/AA/min_dist/95.00'] = {'max': 2.3789316665079001, 'min': 1.5190855070286298} # lost: 252
limits['WW_tran/AA/min_dist/99.00'] = {'max': 2.5381806179989321, 'min': 1.2897093885204844} # lost: 50
limits['WW_tran/AA/min_dist/99.50'] = {'max': 2.6383112921919953, 'min': 1.1021871893193691} # lost: 25
limits['WW_tran/AA/min_dist/99.90'] = {'max': 2.7312443116174383, 'min': 0.98013258708736106} # lost: 5
limits['WW_tran/AA/min_dist/99.99'] = {'max': 2.8674624644393401, 'min': 0.88965504581188803} # lost: 0
limits['WW_tran/AA/n2_z/100.00'] = {'max': 0.99992728, 'min': 0.42448848} # lost: 0
limits['WW_tran/AA/n2_z/95.00'] = {'max': 0.99992728, 'min': 0.61683255} # lost: 252
limits['WW_tran/AA/n2_z/99.00'] = {'max': 0.99992728, 'min': 0.51971358} # lost: 50
limits['WW_tran/AA/n2_z/99.50'] = {'max': 0.99992728, 'min': 0.50185263} # lost: 25
limits['WW_tran/AA/n2_z/99.90'] = {'max': 0.99992728, 'min': 0.42655188} # lost: 5
limits['WW_tran/AA/n2_z/99.99'] = {'max': 0.99992728, 'min': 0.42448848} # lost: 0
limits['WW_tran/AA/nn_ang_norm/100.00'] = {'max': 64.909712399786528, 'min': 0.40734418448693593} # lost: 0
limits['WW_tran/AA/nn_ang_norm/95.00'] = {'max': 51.971223583328843, 'min': 0.40734418448693593} # lost: 252
limits['WW_tran/AA/nn_ang_norm/99.00'] = {'max': 58.646715798829973, 'min': 0.40734418448693593} # lost: 50
limits['WW_tran/AA/nn_ang_norm/99.50'] = {'max': 60.211061345194672, 'min': 0.40734418448693593} # lost: 25
limits['WW_tran/AA/nn_ang_norm/99.90'] = {'max': 64.703358724582102, 'min': 0.40734418448693593} # lost: 5
limits['WW_tran/AA/nn_ang_norm/99.99'] = {'max': 64.909712399786528, 'min': 0.40734418448693593} # lost: 0
limits['WW_tran/AA/rot_ang/100.00'] = {'max': 238.83596725548853, 'min': 121.16403274451147} # lost: 0
limits['WW_tran/AA/rot_ang/95.00'] = {'max': 199.5067300671972, 'min': 160.4932699328028} # lost: 252
limits['WW_tran/AA/rot_ang/99.00'] = {'max': 212.32296640235691, 'min': 147.67703359764309} # lost: 50
limits['WW_tran/AA/rot_ang/99.50'] = {'max': 216.01765500031286, 'min': 143.92233638094243} # lost: 25
limits['WW_tran/AA/rot_ang/99.90'] = {'max': 221.40963336024683, 'min': 130.51587697458422} # lost: 5
limits['WW_tran/AA/rot_ang/99.99'] = {'max': 238.83596725548853, 'min': 121.16403274451147} # lost: 0
limits['WW_tran/AC/dist/100.00'] = {'max': 6.7870194793200156, 'min': 4.8540585222985086} # lost: 0
limits['WW_tran/AC/dist/95.00'] = {'max': 6.5099691855096165, 'min': 5.5288526344464968} # lost: 23
limits['WW_tran/AC/dist/99.00'] = {'max': 6.7332144094965267, 'min': 5.218285117745153} # lost: 4
limits['WW_tran/AC/dist/99.50'] = {'max': 6.7416031275577399, 'min': 5.1915257068375222} # lost: 2
limits['WW_tran/AC/dist/99.90'] = {'max': 6.7870194793200156, 'min': 4.8540585222985086} # lost: 0
limits['WW_tran/AC/dist/99.99'] = {'max': 6.7870194793200156, 'min': 4.8540585222985086} # lost: 0
limits['WW_tran/AC/min_dist/100.00'] = {'max': 2.7917068771186724, 'min': 0.92215515963225492} # lost: 0
limits['WW_tran/AC/min_dist/95.00'] = {'max': 2.436080349426808, 'min': 1.4548538785320801} # lost: 23
limits['WW_tran/AC/min_dist/99.00'] = {'max': 2.5273960689256199, 'min': 1.1523920158177214} # lost: 4
limits['WW_tran/AC/min_dist/99.50'] = {'max': 2.7692435212661186, 'min': 1.0116033662137041} # lost: 2
limits['WW_tran/AC/min_dist/99.90'] = {'max': 2.7917068771186724, 'min': 0.92215515963225492} # lost: 0
limits['WW_tran/AC/min_dist/99.99'] = {'max': 2.7917068771186724, 'min': 0.92215515963225492} # lost: 0
limits['WW_tran/AC/n2_z/100.00'] = {'max': 0.99985009, 'min': 0.43871409} # lost: 0
limits['WW_tran/AC/n2_z/95.00'] = {'max': 0.99985009, 'min': 0.68288207} # lost: 23
limits['WW_tran/AC/n2_z/99.00'] = {'max': 0.99985009, 'min': 0.57627386} # lost: 4
limits['WW_tran/AC/n2_z/99.50'] = {'max': 0.99985009, 'min': 0.50538534} # lost: 2
limits['WW_tran/AC/n2_z/99.90'] = {'max': 0.99985009, 'min': 0.43871409} # lost: 0
limits['WW_tran/AC/n2_z/99.99'] = {'max': 0.99985009, 'min': 0.43871409} # lost: 0
limits['WW_tran/AC/nn_ang_norm/100.00'] = {'max': 64.219337369049143, 'min': 0.91214508322875754} # lost: 0
limits['WW_tran/AC/nn_ang_norm/95.00'] = {'max': 46.941181995491725, 'min': 0.91214508322875754} # lost: 23
limits['WW_tran/AC/nn_ang_norm/99.00'] = {'max': 53.826497622295648, 'min': 0.91214508322875754} # lost: 4
limits['WW_tran/AC/nn_ang_norm/99.50'] = {'max': 60.527531330198045, 'min': 0.91214508322875754} # lost: 2
limits['WW_tran/AC/nn_ang_norm/99.90'] = {'max': 64.219337369049143, 'min': 0.91214508322875754} # lost: 0
limits['WW_tran/AC/nn_ang_norm/99.99'] = {'max': 64.219337369049143, 'min': 0.91214508322875754} # lost: 0
limits['WW_tran/AC/rot_ang/100.00'] = {'max': 239.05281358225363, 'min': 157.58596472566532} # lost: 0
limits['WW_tran/AC/rot_ang/95.00'] = {'max': 222.57880924936563, 'min': 181.05527511870463} # lost: 23
limits['WW_tran/AC/rot_ang/99.00'] = {'max': 226.77502556853437, 'min': 159.96265953926817} # lost: 4
limits['WW_tran/AC/rot_ang/99.50'] = {'max': 229.51338556716195, 'min': 159.59664348905372} # lost: 2
limits['WW_tran/AC/rot_ang/99.90'] = {'max': 239.05281358225363, 'min': 157.58596472566532} # lost: 0
limits['WW_tran/AC/rot_ang/99.99'] = {'max': 239.05281358225363, 'min': 157.58596472566532} # lost: 0
limits['WW_tran/AG/dist/100.00'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/AG/dist/95.00'] = {'max': 6.793414650324177, 'min': 5.2023920188302748} # lost: 4
limits['WW_tran/AG/dist/99.00'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/AG/dist/99.50'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/AG/dist/99.90'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/AG/dist/99.99'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/AG/min_dist/100.00'] = {'max': 2.3845663030287274, 'min': 0.52406759224747368} # lost: 0
limits['WW_tran/AG/min_dist/95.00'] = {'max': 2.3685781623980615, 'min': 1.1150294566190087} # lost: 4
limits['WW_tran/AG/min_dist/99.00'] = {'max': 2.3845663030287274, 'min': 0.52406759224747368} # lost: 0
limits['WW_tran/AG/min_dist/99.50'] = {'max': 2.3845663030287274, 'min': 0.52406759224747368} # lost: 0
limits['WW_tran/AG/min_dist/99.90'] = {'max': 2.3845663030287274, 'min': 0.52406759224747368} # lost: 0
limits['WW_tran/AG/min_dist/99.99'] = {'max': 2.3845663030287274, 'min': 0.52406759224747368} # lost: 0
limits['WW_tran/AG/n2_z/100.00'] = {'max': 0.99974972, 'min': 0.47730592} # lost: 0
limits['WW_tran/AG/n2_z/95.00'] = {'max': 0.99974972, 'min': 0.52339178} # lost: 4
limits['WW_tran/AG/n2_z/99.00'] = {'max': 0.99974972, 'min': 0.47730592} # lost: 0
limits['WW_tran/AG/n2_z/99.50'] = {'max': 0.99974972, 'min': 0.47730592} # lost: 0
limits['WW_tran/AG/n2_z/99.90'] = {'max': 0.99974972, 'min': 0.47730592} # lost: 0
limits['WW_tran/AG/n2_z/99.99'] = {'max': 0.99974972, 'min': 0.47730592} # lost: 0
limits['WW_tran/AG/nn_ang_norm/100.00'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/AG/nn_ang_norm/95.00'] = {'max': 58.292167509203786, 'min': 1.2578773061837554} # lost: 4
limits['WW_tran/AG/nn_ang_norm/99.00'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/AG/nn_ang_norm/99.50'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/AG/nn_ang_norm/99.90'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/AG/nn_ang_norm/99.99'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/AG/rot_ang/100.00'] = {'max': 254.40113961828962, 'min': 142.50832007907533} # lost: 0
limits['WW_tran/AG/rot_ang/95.00'] = {'max': 225.76248267016635, 'min': 147.93037268473856} # lost: 4
limits['WW_tran/AG/rot_ang/99.00'] = {'max': 254.40113961828962, 'min': 142.50832007907533} # lost: 0
limits['WW_tran/AG/rot_ang/99.50'] = {'max': 254.40113961828962, 'min': 142.50832007907533} # lost: 0
limits['WW_tran/AG/rot_ang/99.90'] = {'max': 254.40113961828962, 'min': 142.50832007907533} # lost: 0
limits['WW_tran/AG/rot_ang/99.99'] = {'max': 254.40113961828962, 'min': 142.50832007907533} # lost: 0
limits['WW_tran/AU/dist/100.00'] = {'max': 7.3876129286122119, 'min': 4.6665852324221513} # lost: 0
limits['WW_tran/AU/dist/95.00'] = {'max': 6.1845848040003455, 'min': 5.1867076232395872} # lost: 112
limits['WW_tran/AU/dist/99.00'] = {'max': 6.4668279537756348, 'min': 4.8871221540393854} # lost: 22
limits['WW_tran/AU/dist/99.50'] = {'max': 7.0213651339155216, 'min': 4.7771576845139831} # lost: 11
limits['WW_tran/AU/dist/99.90'] = {'max': 7.3772233049490969, 'min': 4.6857965502080834} # lost: 2
limits['WW_tran/AU/dist/99.99'] = {'max': 7.3876129286122119, 'min': 4.6665852324221513} # lost: 0
limits['WW_tran/AU/min_dist/100.00'] = {'max': 2.681400447181268, 'min': 0.9964974907160965} # lost: 0
limits['WW_tran/AU/min_dist/95.00'] = {'max': 2.3671373181927815, 'min': 1.4998232601785684} # lost: 112
limits['WW_tran/AU/min_dist/99.00'] = {'max': 2.5322830552372451, 'min': 1.2393790990880893} # lost: 22
limits['WW_tran/AU/min_dist/99.50'] = {'max': 2.5848207424438754, 'min': 1.1285326161855245} # lost: 11
limits['WW_tran/AU/min_dist/99.90'] = {'max': 2.6709261031401375, 'min': 1.035128030689817} # lost: 2
limits['WW_tran/AU/min_dist/99.99'] = {'max': 2.681400447181268, 'min': 0.9964974907160965} # lost: 0
limits['WW_tran/AU/n2_z/100.00'] = {'max': 0.99990219, 'min': 0.42384616} # lost: 0
limits['WW_tran/AU/n2_z/95.00'] = {'max': 0.99990219, 'min': 0.76771432} # lost: 112
limits['WW_tran/AU/n2_z/99.00'] = {'max': 0.99990219, 'min': 0.47960952} # lost: 22
limits['WW_tran/AU/n2_z/99.50'] = {'max': 0.99990219, 'min': 0.45715469} # lost: 11
limits['WW_tran/AU/n2_z/99.90'] = {'max': 0.99990219, 'min': 0.4281379} # lost: 2
limits['WW_tran/AU/n2_z/99.99'] = {'max': 0.99990219, 'min': 0.42384616} # lost: 0
limits['WW_tran/AU/nn_ang_norm/100.00'] = {'max': 64.887951417090861, 'min': 0.46435985559427856} # lost: 0
limits['WW_tran/AU/nn_ang_norm/95.00'] = {'max': 39.763845045818492, 'min': 0.46435985559427856} # lost: 112
limits['WW_tran/AU/nn_ang_norm/99.00'] = {'max': 61.519664118466586, 'min': 0.46435985559427856} # lost: 22
limits['WW_tran/AU/nn_ang_norm/99.50'] = {'max': 62.709715298314592, 'min': 0.46435985559427856} # lost: 11
limits['WW_tran/AU/nn_ang_norm/99.90'] = {'max': 64.572314715166243, 'min': 0.46435985559427856} # lost: 2
limits['WW_tran/AU/nn_ang_norm/99.99'] = {'max': 64.887951417090861, 'min': 0.46435985559427856} # lost: 0
limits['WW_tran/AU/rot_ang/100.00'] = {'max': 237.14255904707892, 'min': 158.76460678089686} # lost: 0
limits['WW_tran/AU/rot_ang/95.00'] = {'max': 217.85386215307707, 'min': 181.55275387408284} # lost: 112
limits['WW_tran/AU/rot_ang/99.00'] = {'max': 225.75282406897372, 'min': 170.9337584456172} # lost: 22
limits['WW_tran/AU/rot_ang/99.50'] = {'max': 231.43678480813665, 'min': 166.6424753468396} # lost: 11
limits['WW_tran/AU/rot_ang/99.90'] = {'max': 237.12994245655307, 'min': 159.63670173164635} # lost: 2
limits['WW_tran/AU/rot_ang/99.99'] = {'max': 237.14255904707892, 'min': 158.76460678089686} # lost: 0
limits['WW_tran/CA/dist/100.00'] = {'max': 6.7870194793200156, 'min': 4.8540585222985086} # lost: 0
limits['WW_tran/CA/dist/95.00'] = {'max': 6.5099691855096165, 'min': 5.5288526344464968} # lost: 23
limits['WW_tran/CA/dist/99.00'] = {'max': 6.7332144094965267, 'min': 5.218285117745153} # lost: 4
limits['WW_tran/CA/dist/99.50'] = {'max': 6.7416031275577399, 'min': 5.1915257068375222} # lost: 2
limits['WW_tran/CA/dist/99.90'] = {'max': 6.7870194793200156, 'min': 4.8540585222985086} # lost: 0
limits['WW_tran/CA/dist/99.99'] = {'max': 6.7870194793200156, 'min': 4.8540585222985086} # lost: 0
limits['WW_tran/CA/min_dist/100.00'] = {'max': 2.7917143910892261, 'min': 0.92216965298918552} # lost: 0
limits['WW_tran/CA/min_dist/95.00'] = {'max': 2.436080102789794, 'min': 1.4548415755676545} # lost: 23
limits['WW_tran/CA/min_dist/99.00'] = {'max': 2.5273972960594921, 'min': 1.1523823693062341} # lost: 4
limits['WW_tran/CA/min_dist/99.50'] = {'max': 2.7692264740023966, 'min': 1.0116024920229156} # lost: 2
limits['WW_tran/CA/min_dist/99.90'] = {'max': 2.7917143910892261, 'min': 0.92216965298918552} # lost: 0
limits['WW_tran/CA/min_dist/99.99'] = {'max': 2.7917143910892261, 'min': 0.92216965298918552} # lost: 0
limits['WW_tran/CA/n2_z/100.00'] = {'max': 0.99985009, 'min': 0.43871403} # lost: 0
limits['WW_tran/CA/n2_z/95.00'] = {'max': 0.99985009, 'min': 0.68288207} # lost: 23
limits['WW_tran/CA/n2_z/99.00'] = {'max': 0.99985009, 'min': 0.57627338} # lost: 4
limits['WW_tran/CA/n2_z/99.50'] = {'max': 0.99985009, 'min': 0.50538528} # lost: 2
limits['WW_tran/CA/n2_z/99.90'] = {'max': 0.99985009, 'min': 0.43871403} # lost: 0
limits['WW_tran/CA/n2_z/99.99'] = {'max': 0.99985009, 'min': 0.43871403} # lost: 0
limits['WW_tran/CA/nn_ang_norm/100.00'] = {'max': 64.219337369049143, 'min': 0.91214508322875754} # lost: 0
limits['WW_tran/CA/nn_ang_norm/95.00'] = {'max': 46.941181995491725, 'min': 0.91214508322875754} # lost: 23
limits['WW_tran/CA/nn_ang_norm/99.00'] = {'max': 53.826497622295648, 'min': 0.91214508322875754} # lost: 4
limits['WW_tran/CA/nn_ang_norm/99.50'] = {'max': 60.527531330198045, 'min': 0.91214508322875754} # lost: 2
limits['WW_tran/CA/nn_ang_norm/99.90'] = {'max': 64.219337369049143, 'min': 0.91214508322875754} # lost: 0
limits['WW_tran/CA/nn_ang_norm/99.99'] = {'max': 64.219337369049143, 'min': 0.91214508322875754} # lost: 0
limits['WW_tran/CA/rot_ang/100.00'] = {'max': 202.41403527433468, 'min': 120.94718641774637} # lost: 0
limits['WW_tran/CA/rot_ang/95.00'] = {'max': 177.13363899966023, 'min': 137.40179533182729} # lost: 23
limits['WW_tran/CA/rot_ang/99.00'] = {'max': 200.03734046073183, 'min': 133.22497443146563} # lost: 4
limits['WW_tran/CA/rot_ang/99.50'] = {'max': 200.40335651094628, 'min': 130.48661443283805} # lost: 2
limits['WW_tran/CA/rot_ang/99.90'] = {'max': 202.41403527433468, 'min': 120.94718641774637} # lost: 0
limits['WW_tran/CA/rot_ang/99.99'] = {'max': 202.41403527433468, 'min': 120.94718641774637} # lost: 0
limits['WW_tran/CC/dist/100.00'] = {'max': 6.655850848561041, 'min': 5.2304059939978771} # lost: 0
limits['WW_tran/CC/dist/95.00'] = {'max': 6.4606223884748246, 'min': 5.2554019827706568} # lost: 13
limits['WW_tran/CC/dist/99.00'] = {'max': 6.655850848561041, 'min': 5.2304059939978771} # lost: 2
limits['WW_tran/CC/dist/99.50'] = {'max': 6.655850848561041, 'min': 5.2304059939978771} # lost: 1
limits['WW_tran/CC/dist/99.90'] = {'max': 6.655850848561041, 'min': 5.2304059939978771} # lost: 0
limits['WW_tran/CC/dist/99.99'] = {'max': 6.655850848561041, 'min': 5.2304059939978771} # lost: 0
limits['WW_tran/CC/min_dist/100.00'] = {'max': 2.5512090522274256, 'min': 1.1387774363458012} # lost: 0
limits['WW_tran/CC/min_dist/95.00'] = {'max': 2.3376477245954428, 'min': 1.4686397323370444} # lost: 13
limits['WW_tran/CC/min_dist/99.00'] = {'max': 2.5512072914648964, 'min': 1.138782607124494} # lost: 2
limits['WW_tran/CC/min_dist/99.50'] = {'max': 2.5512072914648964, 'min': 1.1387774363458012} # lost: 1
limits['WW_tran/CC/min_dist/99.90'] = {'max': 2.5512090522274256, 'min': 1.1387774363458012} # lost: 0
limits['WW_tran/CC/min_dist/99.99'] = {'max': 2.5512090522274256, 'min': 1.1387774363458012} # lost: 0
limits['WW_tran/CC/n2_z/100.00'] = {'max': 0.99994689, 'min': 0.45467666} # lost: 0
limits['WW_tran/CC/n2_z/95.00'] = {'max': 0.99994689, 'min': 0.87776607} # lost: 13
limits['WW_tran/CC/n2_z/99.00'] = {'max': 0.99994689, 'min': 0.69334084} # lost: 2
limits['WW_tran/CC/n2_z/99.50'] = {'max': 0.99994689, 'min': 0.45467678} # lost: 1
limits['WW_tran/CC/n2_z/99.90'] = {'max': 0.99994689, 'min': 0.45467666} # lost: 0
limits['WW_tran/CC/n2_z/99.99'] = {'max': 0.99994689, 'min': 0.45467666} # lost: 0
limits['WW_tran/CC/nn_ang_norm/100.00'] = {'max': 63.099049741383659, 'min': 0.11869406690112955} # lost: 0
limits['WW_tran/CC/nn_ang_norm/95.00'] = {'max': 28.774798086414584, 'min': 0.11869406690112955} # lost: 13
limits['WW_tran/CC/nn_ang_norm/99.00'] = {'max': 48.54248228036078, 'min': 0.11869406690112955} # lost: 2
limits['WW_tran/CC/nn_ang_norm/99.50'] = {'max': 63.099049741383659, 'min': 0.11869406690112955} # lost: 1
limits['WW_tran/CC/nn_ang_norm/99.90'] = {'max': 63.099049741383659, 'min': 0.11869406690112955} # lost: 0
limits['WW_tran/CC/nn_ang_norm/99.99'] = {'max': 63.099049741383659, 'min': 0.11869406690112955} # lost: 0
limits['WW_tran/CC/rot_ang/100.00'] = {'max': 203.58787723581099, 'min': 156.41212276418901} # lost: 0
limits['WW_tran/CC/rot_ang/95.00'] = {'max': 194.08628690550239, 'min': 164.49562052715834} # lost: 13
limits['WW_tran/CC/rot_ang/99.00'] = {'max': 198.69629862257028, 'min': 161.30370137742972} # lost: 2
limits['WW_tran/CC/rot_ang/99.50'] = {'max': 198.69629862257028, 'min': 156.41212276418901} # lost: 1
limits['WW_tran/CC/rot_ang/99.90'] = {'max': 203.58787723581099, 'min': 156.41212276418901} # lost: 0
limits['WW_tran/CC/rot_ang/99.99'] = {'max': 203.58787723581099, 'min': 156.41212276418901} # lost: 0
limits['WW_tran/CG/dist/100.00'] = {'max': 7.0544783159898534, 'min': 4.7987744527617275} # lost: 0
limits['WW_tran/CG/dist/95.00'] = {'max': 6.5459084139799097, 'min': 5.3982631116475277} # lost: 75
limits['WW_tran/CG/dist/99.00'] = {'max': 6.7680680140696436, 'min': 5.2143829860000324} # lost: 15
limits['WW_tran/CG/dist/99.50'] = {'max': 6.7752612918197554, 'min': 5.0519884927743819} # lost: 7
limits['WW_tran/CG/dist/99.90'] = {'max': 7.0275932711670048, 'min': 4.7987744527617275} # lost: 1
limits['WW_tran/CG/dist/99.99'] = {'max': 7.0544783159898534, 'min': 4.7987744527617275} # lost: 0
limits['WW_tran/CG/min_dist/100.00'] = {'max': 2.5028341752578589, 'min': 0.37915678433245931} # lost: 0
limits['WW_tran/CG/min_dist/95.00'] = {'max': 2.2499729527742756, 'min': 1.2890321996347245} # lost: 75
limits['WW_tran/CG/min_dist/99.00'] = {'max': 2.3853820601690079, 'min': 0.96670247501361595} # lost: 15
limits['WW_tran/CG/min_dist/99.50'] = {'max': 2.4022536793339349, 'min': 0.92891179117253897} # lost: 7
limits['WW_tran/CG/min_dist/99.90'] = {'max': 2.4494697224494262, 'min': 0.37915678433245931} # lost: 1
limits['WW_tran/CG/min_dist/99.99'] = {'max': 2.5028341752578589, 'min': 0.37915678433245931} # lost: 0
limits['WW_tran/CG/n2_z/100.00'] = {'max': 0.99989009, 'min': 0.43284491} # lost: 0
limits['WW_tran/CG/n2_z/95.00'] = {'max': 0.99989009, 'min': 0.63708413} # lost: 75
limits['WW_tran/CG/n2_z/99.00'] = {'max': 0.99989009, 'min': 0.53591794} # lost: 15
limits['WW_tran/CG/n2_z/99.50'] = {'max': 0.99989009, 'min': 0.49870518} # lost: 7
limits['WW_tran/CG/n2_z/99.90'] = {'max': 0.99989009, 'min': 0.43438786} # lost: 1
limits['WW_tran/CG/n2_z/99.99'] = {'max': 0.99989009, 'min': 0.43284491} # lost: 0
limits['WW_tran/CG/nn_ang_norm/100.00'] = {'max': 64.303321375083627, 'min': 1.1997519694601237} # lost: 0
limits['WW_tran/CG/nn_ang_norm/95.00'] = {'max': 51.061773650057887, 'min': 1.1997519694601237} # lost: 75
limits['WW_tran/CG/nn_ang_norm/99.00'] = {'max': 57.795100492356106, 'min': 1.1997519694601237} # lost: 15
limits['WW_tran/CG/nn_ang_norm/99.50'] = {'max': 60.695861342293007, 'min': 1.1997519694601237} # lost: 7
limits['WW_tran/CG/nn_ang_norm/99.90'] = {'max': 64.243017634901577, 'min': 1.1997519694601237} # lost: 1
limits['WW_tran/CG/nn_ang_norm/99.99'] = {'max': 64.303321375083627, 'min': 1.1997519694601237} # lost: 0
limits['WW_tran/CG/rot_ang/100.00'] = {'max': 242.9924382550127, 'min': 115.0347321917873} # lost: 0
limits['WW_tran/CG/rot_ang/95.00'] = {'max': 174.20813624210237, 'min': 142.09150256062048} # lost: 75
limits['WW_tran/CG/rot_ang/99.00'] = {'max': 186.42294579036013, 'min': 129.95521041515835} # lost: 15
limits['WW_tran/CG/rot_ang/99.50'] = {'max': 203.77077586321417, 'min': 126.54395525834082} # lost: 7
limits['WW_tran/CG/rot_ang/99.90'] = {'max': 227.50743454506764, 'min': 115.0347321917873} # lost: 1
limits['WW_tran/CG/rot_ang/99.99'] = {'max': 242.9924382550127, 'min': 115.0347321917873} # lost: 0
limits['WW_tran/CU/dist/100.00'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/CU/dist/95.00'] = {'max': 7.1772911682937215, 'min': 5.4383359118849555} # lost: 4
limits['WW_tran/CU/dist/99.00'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/CU/dist/99.50'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/CU/dist/99.90'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/CU/dist/99.99'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/CU/min_dist/100.00'] = {'max': 2.4729308161623429, 'min': 1.45965206502251} # lost: 0
limits['WW_tran/CU/min_dist/95.00'] = {'max': 2.4056781438109898, 'min': 1.6550643738336159} # lost: 4
limits['WW_tran/CU/min_dist/99.00'] = {'max': 2.4729308161623429, 'min': 1.45965206502251} # lost: 0
limits['WW_tran/CU/min_dist/99.50'] = {'max': 2.4729308161623429, 'min': 1.45965206502251} # lost: 0
limits['WW_tran/CU/min_dist/99.90'] = {'max': 2.4729308161623429, 'min': 1.45965206502251} # lost: 0
limits['WW_tran/CU/min_dist/99.99'] = {'max': 2.4729308161623429, 'min': 1.45965206502251} # lost: 0
limits['WW_tran/CU/n2_z/100.00'] = {'max': 0.98374856, 'min': 0.54590058} # lost: 0
limits['WW_tran/CU/n2_z/95.00'] = {'max': 0.98374856, 'min': 0.77034068} # lost: 4
limits['WW_tran/CU/n2_z/99.00'] = {'max': 0.98374856, 'min': 0.54590058} # lost: 0
limits['WW_tran/CU/n2_z/99.50'] = {'max': 0.98374856, 'min': 0.54590058} # lost: 0
limits['WW_tran/CU/n2_z/99.90'] = {'max': 0.98374856, 'min': 0.54590058} # lost: 0
limits['WW_tran/CU/n2_z/99.99'] = {'max': 0.98374856, 'min': 0.54590058} # lost: 0
limits['WW_tran/CU/nn_ang_norm/100.00'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/CU/nn_ang_norm/95.00'] = {'max': 38.952381006380541, 'min': 10.806602361389114} # lost: 4
limits['WW_tran/CU/nn_ang_norm/99.00'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/CU/nn_ang_norm/99.50'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/CU/nn_ang_norm/99.90'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/CU/nn_ang_norm/99.99'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/CU/rot_ang/100.00'] = {'max': 198.58103120372749, 'min': 142.56182941021382} # lost: 0
limits['WW_tran/CU/rot_ang/95.00'] = {'max': 186.19167466035515, 'min': 145.47371735326109} # lost: 4
limits['WW_tran/CU/rot_ang/99.00'] = {'max': 198.58103120372749, 'min': 142.56182941021382} # lost: 0
limits['WW_tran/CU/rot_ang/99.50'] = {'max': 198.58103120372749, 'min': 142.56182941021382} # lost: 0
limits['WW_tran/CU/rot_ang/99.90'] = {'max': 198.58103120372749, 'min': 142.56182941021382} # lost: 0
limits['WW_tran/CU/rot_ang/99.99'] = {'max': 198.58103120372749, 'min': 142.56182941021382} # lost: 0
limits['WW_tran/GA/dist/100.00'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/GA/dist/95.00'] = {'max': 6.793414650324177, 'min': 5.2023920188302748} # lost: 4
limits['WW_tran/GA/dist/99.00'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/GA/dist/99.50'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/GA/dist/99.90'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/GA/dist/99.99'] = {'max': 6.7989118718336012, 'min': 4.9850634768738091} # lost: 0
limits['WW_tran/GA/min_dist/100.00'] = {'max': 2.3845645816136711, 'min': 0.52406474922702473} # lost: 0
limits['WW_tran/GA/min_dist/95.00'] = {'max': 2.3685783538971643, 'min': 1.1150367062927462} # lost: 4
limits['WW_tran/GA/min_dist/99.00'] = {'max': 2.3845645816136711, 'min': 0.52406474922702473} # lost: 0
limits['WW_tran/GA/min_dist/99.50'] = {'max': 2.3845645816136711, 'min': 0.52406474922702473} # lost: 0
limits['WW_tran/GA/min_dist/99.90'] = {'max': 2.3845645816136711, 'min': 0.52406474922702473} # lost: 0
limits['WW_tran/GA/min_dist/99.99'] = {'max': 2.3845645816136711, 'min': 0.52406474922702473} # lost: 0
limits['WW_tran/GA/n2_z/100.00'] = {'max': 0.99974978, 'min': 0.47730598} # lost: 0
limits['WW_tran/GA/n2_z/95.00'] = {'max': 0.99974978, 'min': 0.5233919} # lost: 4
limits['WW_tran/GA/n2_z/99.00'] = {'max': 0.99974978, 'min': 0.47730598} # lost: 0
limits['WW_tran/GA/n2_z/99.50'] = {'max': 0.99974978, 'min': 0.47730598} # lost: 0
limits['WW_tran/GA/n2_z/99.90'] = {'max': 0.99974978, 'min': 0.47730598} # lost: 0
limits['WW_tran/GA/n2_z/99.99'] = {'max': 0.99974978, 'min': 0.47730598} # lost: 0
limits['WW_tran/GA/nn_ang_norm/100.00'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/GA/nn_ang_norm/95.00'] = {'max': 58.292167509203786, 'min': 1.2578773061837554} # lost: 4
limits['WW_tran/GA/nn_ang_norm/99.00'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/GA/nn_ang_norm/99.50'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/GA/nn_ang_norm/99.90'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/GA/nn_ang_norm/99.99'] = {'max': 61.964568980622879, 'min': 1.2578773061837554} # lost: 0
limits['WW_tran/GA/rot_ang/100.00'] = {'max': 217.49167992092467, 'min': 105.5988603817104} # lost: 0
limits['WW_tran/GA/rot_ang/95.00'] = {'max': 212.06962731526144, 'min': 134.23751732983365} # lost: 4
limits['WW_tran/GA/rot_ang/99.00'] = {'max': 217.49167992092467, 'min': 105.5988603817104} # lost: 0
limits['WW_tran/GA/rot_ang/99.50'] = {'max': 217.49167992092467, 'min': 105.5988603817104} # lost: 0
limits['WW_tran/GA/rot_ang/99.90'] = {'max': 217.49167992092467, 'min': 105.5988603817104} # lost: 0
limits['WW_tran/GA/rot_ang/99.99'] = {'max': 217.49167992092467, 'min': 105.5988603817104} # lost: 0
limits['WW_tran/GC/dist/100.00'] = {'max': 7.0544783159898534, 'min': 4.7987744527617275} # lost: 0
limits['WW_tran/GC/dist/95.00'] = {'max': 6.5459084139799097, 'min': 5.3982631116475277} # lost: 75
limits['WW_tran/GC/dist/99.00'] = {'max': 6.7680680140696436, 'min': 5.2143829860000324} # lost: 15
limits['WW_tran/GC/dist/99.50'] = {'max': 6.7752612918197554, 'min': 5.0519884927743819} # lost: 7
limits['WW_tran/GC/dist/99.90'] = {'max': 7.0275932711670048, 'min': 4.7987744527617275} # lost: 1
limits['WW_tran/GC/dist/99.99'] = {'max': 7.0544783159898534, 'min': 4.7987744527617275} # lost: 0
limits['WW_tran/GC/min_dist/100.00'] = {'max': 2.5028332332257208, 'min': 0.37915941526165914} # lost: 0
limits['WW_tran/GC/min_dist/95.00'] = {'max': 2.2499757855525915, 'min': 1.2890328555367963} # lost: 75
limits['WW_tran/GC/min_dist/99.00'] = {'max': 2.3853910862385383, 'min': 0.96670519231344021} # lost: 15
limits['WW_tran/GC/min_dist/99.50'] = {'max': 2.4022607393869766, 'min': 0.92891067123379756} # lost: 7
limits['WW_tran/GC/min_dist/99.90'] = {'max': 2.4494791090604928, 'min': 0.37915941526165914} # lost: 1
limits['WW_tran/GC/min_dist/99.99'] = {'max': 2.5028332332257208, 'min': 0.37915941526165914} # lost: 0
limits['WW_tran/GC/n2_z/100.00'] = {'max': 0.99989003, 'min': 0.43284464} # lost: 0
limits['WW_tran/GC/n2_z/95.00'] = {'max': 0.99989003, 'min': 0.63708395} # lost: 75
limits['WW_tran/GC/n2_z/99.00'] = {'max': 0.99989003, 'min': 0.53591806} # lost: 15
limits['WW_tran/GC/n2_z/99.50'] = {'max': 0.99989003, 'min': 0.49870476} # lost: 7
limits['WW_tran/GC/n2_z/99.90'] = {'max': 0.99989003, 'min': 0.43438765} # lost: 1
limits['WW_tran/GC/n2_z/99.99'] = {'max': 0.99989003, 'min': 0.43284464} # lost: 0
limits['WW_tran/GC/nn_ang_norm/100.00'] = {'max': 64.303321375083627, 'min': 1.1997519694601237} # lost: 0
limits['WW_tran/GC/nn_ang_norm/95.00'] = {'max': 51.061773650057887, 'min': 1.1997519694601237} # lost: 75
limits['WW_tran/GC/nn_ang_norm/99.00'] = {'max': 57.795100492356106, 'min': 1.1997519694601237} # lost: 15
limits['WW_tran/GC/nn_ang_norm/99.50'] = {'max': 60.695861342293007, 'min': 1.1997519694601237} # lost: 7
limits['WW_tran/GC/nn_ang_norm/99.90'] = {'max': 64.243017634901577, 'min': 1.1997519694601237} # lost: 1
limits['WW_tran/GC/nn_ang_norm/99.99'] = {'max': 64.303321375083627, 'min': 1.1997519694601237} # lost: 0
limits['WW_tran/GC/rot_ang/100.00'] = {'max': 244.9652678082127, 'min': 117.0075617449873} # lost: 0
limits['WW_tran/GC/rot_ang/95.00'] = {'max': 217.82361987230905, 'min': 185.36122354782606} # lost: 75
limits['WW_tran/GC/rot_ang/99.00'] = {'max': 227.19505501575441, 'min': 163.28893340309853} # lost: 15
limits['WW_tran/GC/rot_ang/99.50'] = {'max': 233.24630822592354, 'min': 156.18921077081961} # lost: 7
limits['WW_tran/GC/rot_ang/99.90'] = {'max': 240.59818016337459, 'min': 117.0075617449873} # lost: 1
limits['WW_tran/GC/rot_ang/99.99'] = {'max': 244.9652678082127, 'min': 117.0075617449873} # lost: 0
limits['WW_tran/GG/dist/100.00'] = {'max': 6.6924416625041943, 'min': 4.7785740701965222} # lost: 0
limits['WW_tran/GG/dist/95.00'] = {'max': 6.4644159647402137, 'min': 5.1996362389124924} # lost: 33
limits['WW_tran/GG/dist/99.00'] = {'max': 6.662531546103847, 'min': 4.8828625414779321} # lost: 6
limits['WW_tran/GG/dist/99.50'] = {'max': 6.662531546103847, 'min': 4.7785740701965222} # lost: 3
limits['WW_tran/GG/dist/99.90'] = {'max': 6.6924416625041943, 'min': 4.7785740701965222} # lost: 0
limits['WW_tran/GG/dist/99.99'] = {'max': 6.6924416625041943, 'min': 4.7785740701965222} # lost: 0
limits['WW_tran/GG/min_dist/100.00'] = {'max': 2.5530135193223167, 'min': 0.58820502186870893} # lost: 0
limits['WW_tran/GG/min_dist/95.00'] = {'max': 2.3215085531813373, 'min': 1.5129383569490895} # lost: 33
limits['WW_tran/GG/min_dist/99.00'] = {'max': 2.5517331277218425, 'min': 1.1491034655380754} # lost: 6
limits['WW_tran/GG/min_dist/99.50'] = {'max': 2.5517370759072384, 'min': 0.58821099881784922} # lost: 3
limits['WW_tran/GG/min_dist/99.90'] = {'max': 2.5530135193223167, 'min': 0.58820502186870893} # lost: 0
limits['WW_tran/GG/min_dist/99.99'] = {'max': 2.5530135193223167, 'min': 0.58820502186870893} # lost: 0
limits['WW_tran/GG/n2_z/100.00'] = {'max': 0.99919504, 'min': 0.46094009} # lost: 0
limits['WW_tran/GG/n2_z/95.00'] = {'max': 0.99919504, 'min': 0.85564834} # lost: 33
limits['WW_tran/GG/n2_z/99.00'] = {'max': 0.99919504, 'min': 0.63973236} # lost: 6
limits['WW_tran/GG/n2_z/99.50'] = {'max': 0.99919504, 'min': 0.52356905} # lost: 3
limits['WW_tran/GG/n2_z/99.90'] = {'max': 0.99919504, 'min': 0.46094009} # lost: 0
limits['WW_tran/GG/n2_z/99.99'] = {'max': 0.99919504, 'min': 0.46094009} # lost: 0
limits['WW_tran/GG/nn_ang_norm/100.00'] = {'max': 60.39911694361264, 'min': 2.1651883230274365} # lost: 0
limits['WW_tran/GG/nn_ang_norm/95.00'] = {'max': 31.282242492996303, 'min': 2.1651883230274365} # lost: 33
limits['WW_tran/GG/nn_ang_norm/99.00'] = {'max': 50.301057916153134, 'min': 2.1651883230274365} # lost: 6
limits['WW_tran/GG/nn_ang_norm/99.50'] = {'max': 55.61563493952923, 'min': 2.1651883230274365} # lost: 3
limits['WW_tran/GG/nn_ang_norm/99.90'] = {'max': 60.39911694361264, 'min': 2.1651883230274365} # lost: 0
limits['WW_tran/GG/nn_ang_norm/99.99'] = {'max': 60.39911694361264, 'min': 2.1651883230274365} # lost: 0
limits['WW_tran/GG/rot_ang/100.00'] = {'max': 213.91977089115829, 'min': 146.08022910884171} # lost: 0
limits['WW_tran/GG/rot_ang/95.00'] = {'max': 199.18839566924169, 'min': 160.25881424971234} # lost: 33
limits['WW_tran/GG/rot_ang/99.00'] = {'max': 208.47521014699319, 'min': 151.52478985300681} # lost: 6
limits['WW_tran/GG/rot_ang/99.50'] = {'max': 208.56993595526023, 'min': 147.31737873477675} # lost: 3
limits['WW_tran/GG/rot_ang/99.90'] = {'max': 213.91977089115829, 'min': 146.08022910884171} # lost: 0
limits['WW_tran/GG/rot_ang/99.99'] = {'max': 213.91977089115829, 'min': 146.08022910884171} # lost: 0
limits['WW_tran/GU/dist/100.00'] = {'max': 7.2216157443273996, 'min': 5.2571427185148227} # lost: 0
limits['WW_tran/GU/dist/95.00'] = {'max': 6.758391187099507, 'min': 5.4172081286980536} # lost: 12
limits['WW_tran/GU/dist/99.00'] = {'max': 7.1969420482975064, 'min': 5.3235250337641702} # lost: 2
limits['WW_tran/GU/dist/99.50'] = {'max': 7.1969420482975064, 'min': 5.2571427185148227} # lost: 1
limits['WW_tran/GU/dist/99.90'] = {'max': 7.2216157443273996, 'min': 5.2571427185148227} # lost: 0
limits['WW_tran/GU/dist/99.99'] = {'max': 7.2216157443273996, 'min': 5.2571427185148227} # lost: 0
limits['WW_tran/GU/min_dist/100.00'] = {'max': 2.4075784630416233, 'min': 0.70108612110533663} # lost: 0
limits['WW_tran/GU/min_dist/95.00'] = {'max': 2.2592408673793223, 'min': 0.91867878298574945} # lost: 12
limits['WW_tran/GU/min_dist/99.00'] = {'max': 2.3187954942899651, 'min': 0.72380570075091732} # lost: 2
limits['WW_tran/GU/min_dist/99.50'] = {'max': 2.3187954942899651, 'min': 0.70108612110533663} # lost: 1
limits['WW_tran/GU/min_dist/99.90'] = {'max': 2.4075784630416233, 'min': 0.70108612110533663} # lost: 0
limits['WW_tran/GU/min_dist/99.99'] = {'max': 2.4075784630416233, 'min': 0.70108612110533663} # lost: 0
limits['WW_tran/GU/n2_z/100.00'] = {'max': 0.99733871, 'min': 0.52963507} # lost: 0
limits['WW_tran/GU/n2_z/95.00'] = {'max': 0.99733871, 'min': 0.60826004} # lost: 12
limits['WW_tran/GU/n2_z/99.00'] = {'max': 0.99733871, 'min': 0.53946257} # lost: 2
limits['WW_tran/GU/n2_z/99.50'] = {'max': 0.99733871, 'min': 0.5299983} # lost: 1
limits['WW_tran/GU/n2_z/99.90'] = {'max': 0.99733871, 'min': 0.52963507} # lost: 0
limits['WW_tran/GU/n2_z/99.99'] = {'max': 0.99733871, 'min': 0.52963507} # lost: 0
limits['WW_tran/GU/nn_ang_norm/100.00'] = {'max': 59.101524435282784, 'min': 3.9527491472232081} # lost: 0
limits['WW_tran/GU/nn_ang_norm/95.00'] = {'max': 53.365060287253343, 'min': 3.9527491472232081} # lost: 12
limits['WW_tran/GU/nn_ang_norm/99.00'] = {'max': 57.904916273831567, 'min': 3.9527491472232081} # lost: 2
limits['WW_tran/GU/nn_ang_norm/99.50'] = {'max': 58.01154235696464, 'min': 3.9527491472232081} # lost: 1
limits['WW_tran/GU/nn_ang_norm/99.90'] = {'max': 59.101524435282784, 'min': 3.9527491472232081} # lost: 0
limits['WW_tran/GU/nn_ang_norm/99.99'] = {'max': 59.101524435282784, 'min': 3.9527491472232081} # lost: 0
limits['WW_tran/GU/rot_ang/100.00'] = {'max': 244.38320960679698, 'min': 158.7132630420528} # lost: 0
limits['WW_tran/GU/rot_ang/95.00'] = {'max': 229.78350325349791, 'min': 176.11859780781788} # lost: 12
limits['WW_tran/GU/rot_ang/99.00'] = {'max': 236.31903302054124, 'min': 165.81921619102337} # lost: 2
limits['WW_tran/GU/rot_ang/99.50'] = {'max': 236.31903302054124, 'min': 158.7132630420528} # lost: 1
limits['WW_tran/GU/rot_ang/99.90'] = {'max': 244.38320960679698, 'min': 158.7132630420528} # lost: 0
limits['WW_tran/GU/rot_ang/99.99'] = {'max': 244.38320960679698, 'min': 158.7132630420528} # lost: 0
limits['WW_tran/UA/dist/100.00'] = {'max': 7.3876129286122119, 'min': 4.6665852324221513} # lost: 0
limits['WW_tran/UA/dist/95.00'] = {'max': 6.1845848040003455, 'min': 5.1867076232395872} # lost: 112
limits['WW_tran/UA/dist/99.00'] = {'max': 6.4668279537756348, 'min': 4.8871221540393854} # lost: 22
limits['WW_tran/UA/dist/99.50'] = {'max': 7.0213651339155216, 'min': 4.7771576845139831} # lost: 11
limits['WW_tran/UA/dist/99.90'] = {'max': 7.3772233049490969, 'min': 4.6857965502080834} # lost: 2
limits['WW_tran/UA/dist/99.99'] = {'max': 7.3876129286122119, 'min': 4.6665852324221513} # lost: 0
limits['WW_tran/UA/min_dist/100.00'] = {'max': 2.6813921688549542, 'min': 0.9964927343476977} # lost: 0
limits['WW_tran/UA/min_dist/95.00'] = {'max': 2.3671228912532905, 'min': 1.4998085613865946} # lost: 112
limits['WW_tran/UA/min_dist/99.00'] = {'max': 2.5322859973585339, 'min': 1.2393939023050802} # lost: 22
limits['WW_tran/UA/min_dist/99.50'] = {'max': 2.5848212807450888, 'min': 1.1285483887341592} # lost: 11
limits['WW_tran/UA/min_dist/99.90'] = {'max': 2.6709206349682151, 'min': 1.0351255730122251} # lost: 2
limits['WW_tran/UA/min_dist/99.99'] = {'max': 2.6813921688549542, 'min': 0.9964927343476977} # lost: 0
limits['WW_tran/UA/n2_z/100.00'] = {'max': 0.99990219, 'min': 0.42384622} # lost: 0
limits['WW_tran/UA/n2_z/95.00'] = {'max': 0.99990219, 'min': 0.76771438} # lost: 112
limits['WW_tran/UA/n2_z/99.00'] = {'max': 0.99990219, 'min': 0.47960955} # lost: 22
limits['WW_tran/UA/n2_z/99.50'] = {'max': 0.99990219, 'min': 0.45715466} # lost: 11
limits['WW_tran/UA/n2_z/99.90'] = {'max': 0.99990219, 'min': 0.42813745} # lost: 2
limits['WW_tran/UA/n2_z/99.99'] = {'max': 0.99990219, 'min': 0.42384622} # lost: 0
limits['WW_tran/UA/nn_ang_norm/100.00'] = {'max': 64.887951417090861, 'min': 0.46435985559427856} # lost: 0
limits['WW_tran/UA/nn_ang_norm/95.00'] = {'max': 39.763845045818492, 'min': 0.46435985559427856} # lost: 112
limits['WW_tran/UA/nn_ang_norm/99.00'] = {'max': 61.519664118466586, 'min': 0.46435985559427856} # lost: 22
limits['WW_tran/UA/nn_ang_norm/99.50'] = {'max': 62.709715298314592, 'min': 0.46435985559427856} # lost: 11
limits['WW_tran/UA/nn_ang_norm/99.90'] = {'max': 64.572314715166243, 'min': 0.46435985559427856} # lost: 2
limits['WW_tran/UA/nn_ang_norm/99.99'] = {'max': 64.887951417090861, 'min': 0.46435985559427856} # lost: 0
limits['WW_tran/UA/rot_ang/100.00'] = {'max': 201.23539321910314, 'min': 122.85744095292107} # lost: 0
limits['WW_tran/UA/rot_ang/95.00'] = {'max': 178.44724612591716, 'min': 142.14613784692293} # lost: 112
limits['WW_tran/UA/rot_ang/99.00'] = {'max': 189.0662415543828, 'min': 134.24717593102628} # lost: 22
limits['WW_tran/UA/rot_ang/99.50'] = {'max': 193.10516140204507, 'min': 124.51287888500333} # lost: 11
limits['WW_tran/UA/rot_ang/99.90'] = {'max': 200.36329826835365, 'min': 122.87005754344693} # lost: 2
limits['WW_tran/UA/rot_ang/99.99'] = {'max': 201.23539321910314, 'min': 122.85744095292107} # lost: 0
limits['WW_tran/UC/dist/100.00'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/UC/dist/95.00'] = {'max': 7.1772911682937215, 'min': 5.4383359118849555} # lost: 4
limits['WW_tran/UC/dist/99.00'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/UC/dist/99.50'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/UC/dist/99.90'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/UC/dist/99.99'] = {'max': 7.4048924198692641, 'min': 5.1848103255296261} # lost: 0
limits['WW_tran/UC/min_dist/100.00'] = {'max': 2.4729280472408139, 'min': 1.4596567682470503} # lost: 0
limits['WW_tran/UC/min_dist/95.00'] = {'max': 2.4056785867726993, 'min': 1.6550759359847711} # lost: 4
limits['WW_tran/UC/min_dist/99.00'] = {'max': 2.4729280472408139, 'min': 1.4596567682470503} # lost: 0
limits['WW_tran/UC/min_dist/99.50'] = {'max': 2.4729280472408139, 'min': 1.4596567682470503} # lost: 0
limits['WW_tran/UC/min_dist/99.90'] = {'max': 2.4729280472408139, 'min': 1.4596567682470503} # lost: 0
limits['WW_tran/UC/min_dist/99.99'] = {'max': 2.4729280472408139, 'min': 1.4596567682470503} # lost: 0
limits['WW_tran/UC/n2_z/100.00'] = {'max': 0.98374856, 'min': 0.54590064} # lost: 0
limits['WW_tran/UC/n2_z/95.00'] = {'max': 0.98374856, 'min': 0.77034056} # lost: 4
limits['WW_tran/UC/n2_z/99.00'] = {'max': 0.98374856, 'min': 0.54590064} # lost: 0
limits['WW_tran/UC/n2_z/99.50'] = {'max': 0.98374856, 'min': 0.54590064} # lost: 0
limits['WW_tran/UC/n2_z/99.90'] = {'max': 0.98374856, 'min': 0.54590064} # lost: 0
limits['WW_tran/UC/n2_z/99.99'] = {'max': 0.98374856, 'min': 0.54590064} # lost: 0
limits['WW_tran/UC/nn_ang_norm/100.00'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/UC/nn_ang_norm/95.00'] = {'max': 38.952381006380541, 'min': 10.806602361389114} # lost: 4
limits['WW_tran/UC/nn_ang_norm/99.00'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/UC/nn_ang_norm/99.50'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/UC/nn_ang_norm/99.90'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/UC/nn_ang_norm/99.99'] = {'max': 54.120417737754224, 'min': 10.806602361389114} # lost: 0
limits['WW_tran/UC/rot_ang/100.00'] = {'max': 217.43817058978618, 'min': 161.41896879627251} # lost: 0
limits['WW_tran/UC/rot_ang/95.00'] = {'max': 214.52628264673891, 'min': 173.80832533964485} # lost: 4
limits['WW_tran/UC/rot_ang/99.00'] = {'max': 217.43817058978618, 'min': 161.41896879627251} # lost: 0
limits['WW_tran/UC/rot_ang/99.50'] = {'max': 217.43817058978618, 'min': 161.41896879627251} # lost: 0
limits['WW_tran/UC/rot_ang/99.90'] = {'max': 217.43817058978618, 'min': 161.41896879627251} # lost: 0
limits['WW_tran/UC/rot_ang/99.99'] = {'max': 217.43817058978618, 'min': 161.41896879627251} # lost: 0
limits['WW_tran/UG/dist/100.00'] = {'max': 7.2216157443273996, 'min': 5.2571427185148227} # lost: 0
limits['WW_tran/UG/dist/95.00'] = {'max': 6.758391187099507, 'min': 5.4172081286980536} # lost: 12
limits['WW_tran/UG/dist/99.00'] = {'max': 7.1969420482975064, 'min': 5.3235250337641702} # lost: 2
limits['WW_tran/UG/dist/99.50'] = {'max': 7.1969420482975064, 'min': 5.2571427185148227} # lost: 1
limits['WW_tran/UG/dist/99.90'] = {'max': 7.2216157443273996, 'min': 5.2571427185148227} # lost: 0
limits['WW_tran/UG/dist/99.99'] = {'max': 7.2216157443273996, 'min': 5.2571427185148227} # lost: 0
limits['WW_tran/UG/min_dist/100.00'] = {'max': 2.407576153081421, 'min': 0.70106597982511565} # lost: 0
limits['WW_tran/UG/min_dist/95.00'] = {'max': 2.2592518479610408, 'min': 0.91865894537274517} # lost: 12
limits['WW_tran/UG/min_dist/99.00'] = {'max': 2.3187963431281684, 'min': 0.72380159954389323} # lost: 2
limits['WW_tran/UG/min_dist/99.50'] = {'max': 2.3187963431281684, 'min': 0.70106597982511565} # lost: 1
limits['WW_tran/UG/min_dist/99.90'] = {'max': 2.407576153081421, 'min': 0.70106597982511565} # lost: 0
limits['WW_tran/UG/min_dist/99.99'] = {'max': 2.407576153081421, 'min': 0.70106597982511565} # lost: 0
limits['WW_tran/UG/n2_z/100.00'] = {'max': 0.99733871, 'min': 0.52963507} # lost: 0
limits['WW_tran/UG/n2_z/95.00'] = {'max': 0.99733871, 'min': 0.60826021} # lost: 12
limits['WW_tran/UG/n2_z/99.00'] = {'max': 0.99733871, 'min': 0.53946239} # lost: 2
limits['WW_tran/UG/n2_z/99.50'] = {'max': 0.99733871, 'min': 0.5299983} # lost: 1
limits['WW_tran/UG/n2_z/99.90'] = {'max': 0.99733871, 'min': 0.52963507} # lost: 0
limits['WW_tran/UG/n2_z/99.99'] = {'max': 0.99733871, 'min': 0.52963507} # lost: 0
limits['WW_tran/UG/nn_ang_norm/100.00'] = {'max': 59.101524435282784, 'min': 3.9527491472232081} # lost: 0
limits['WW_tran/UG/nn_ang_norm/95.00'] = {'max': 53.365060287253343, 'min': 3.9527491472232081} # lost: 12
limits['WW_tran/UG/nn_ang_norm/99.00'] = {'max': 57.904916273831567, 'min': 3.9527491472232081} # lost: 2
limits['WW_tran/UG/nn_ang_norm/99.50'] = {'max': 58.01154235696464, 'min': 3.9527491472232081} # lost: 1
limits['WW_tran/UG/nn_ang_norm/99.90'] = {'max': 59.101524435282784, 'min': 3.9527491472232081} # lost: 0
limits['WW_tran/UG/nn_ang_norm/99.99'] = {'max': 59.101524435282784, 'min': 3.9527491472232081} # lost: 0
limits['WW_tran/UG/rot_ang/100.00'] = {'max': 201.2867369579472, 'min': 115.61679039320303} # lost: 0
limits['WW_tran/UG/rot_ang/95.00'] = {'max': 183.88140219218212, 'min': 130.21649674650209} # lost: 12
limits['WW_tran/UG/rot_ang/99.00'] = {'max': 194.18078380897663, 'min': 123.68096697945876} # lost: 2
limits['WW_tran/UG/rot_ang/99.50'] = {'max': 194.18078380897663, 'min': 115.61679039320303} # lost: 1
limits['WW_tran/UG/rot_ang/99.90'] = {'max': 201.2867369579472, 'min': 115.61679039320303} # lost: 0
limits['WW_tran/UG/rot_ang/99.99'] = {'max': 201.2867369579472, 'min': 115.61679039320303} # lost: 0
limits['WW_tran/UU/dist/100.00'] = {'max': 6.477751923944334, 'min': 5.0021248044269182} # lost: 0
limits['WW_tran/UU/dist/95.00'] = {'max': 6.3130333810694701, 'min': 5.4730918920516789} # lost: 65
limits['WW_tran/UU/dist/99.00'] = {'max': 6.4025626096071218, 'min': 5.284562793881622} # lost: 13
limits['WW_tran/UU/dist/99.50'] = {'max': 6.4153072393592652, 'min': 5.2704133822638504} # lost: 6
limits['WW_tran/UU/dist/99.90'] = {'max': 6.477751923944334, 'min': 5.0021248044269182} # lost: 1
limits['WW_tran/UU/dist/99.99'] = {'max': 6.477751923944334, 'min': 5.0021248044269182} # lost: 0
limits['WW_tran/UU/min_dist/100.00'] = {'max': 2.4038540092199003, 'min': 1.2163773970133909} # lost: 0
limits['WW_tran/UU/min_dist/95.00'] = {'max': 2.1913412469416693, 'min': 1.482962108462611} # lost: 65
limits['WW_tran/UU/min_dist/99.00'] = {'max': 2.3031306108687137, 'min': 1.2988909941413331} # lost: 13
limits['WW_tran/UU/min_dist/99.50'] = {'max': 2.4007853058276165, 'min': 1.287246539893008} # lost: 6
limits['WW_tran/UU/min_dist/99.90'] = {'max': 2.4038340060341725, 'min': 1.2163773970133909} # lost: 1
limits['WW_tran/UU/min_dist/99.99'] = {'max': 2.4038540092199003, 'min': 1.2163773970133909} # lost: 0
limits['WW_tran/UU/n2_z/100.00'] = {'max': 0.9999463, 'min': 0.49236146} # lost: 0
limits['WW_tran/UU/n2_z/95.00'] = {'max': 0.9999463, 'min': 0.76193684} # lost: 65
limits['WW_tran/UU/n2_z/99.00'] = {'max': 0.9999463, 'min': 0.63227415} # lost: 13
limits['WW_tran/UU/n2_z/99.50'] = {'max': 0.9999463, 'min': 0.58649343} # lost: 6
limits['WW_tran/UU/n2_z/99.90'] = {'max': 0.9999463, 'min': 0.49236163} # lost: 1
limits['WW_tran/UU/n2_z/99.99'] = {'max': 0.9999463, 'min': 0.49236146} # lost: 0
limits['WW_tran/UU/nn_ang_norm/100.00'] = {'max': 60.404055170382556, 'min': 0.3906706788667299} # lost: 0
limits['WW_tran/UU/nn_ang_norm/95.00'] = {'max': 40.609664936781606, 'min': 0.3906706788667299} # lost: 65
limits['WW_tran/UU/nn_ang_norm/99.00'] = {'max': 50.7879240454754, 'min': 0.3906706788667299} # lost: 13
limits['WW_tran/UU/nn_ang_norm/99.50'] = {'max': 56.010150081083751, 'min': 0.3906706788667299} # lost: 6
limits['WW_tran/UU/nn_ang_norm/99.90'] = {'max': 60.404055170382556, 'min': 0.3906706788667299} # lost: 1
limits['WW_tran/UU/nn_ang_norm/99.99'] = {'max': 60.404055170382556, 'min': 0.3906706788667299} # lost: 0
limits['WW_tran/UU/rot_ang/100.00'] = {'max': 219.45210452032438, 'min': 140.54789547967562} # lost: 0
limits['WW_tran/UU/rot_ang/95.00'] = {'max': 197.10679346188761, 'min': 162.44550047816571} # lost: 65
limits['WW_tran/UU/rot_ang/99.00'] = {'max': 207.39465028067767, 'min': 149.15160873683146} # lost: 13
limits['WW_tran/UU/rot_ang/99.50'] = {'max': 212.68152981020285, 'min': 147.31847018979715} # lost: 6
limits['WW_tran/UU/rot_ang/99.90'] = {'max': 219.43596944272878, 'min': 140.54789547967562} # lost: 1
limits['WW_tran/UU/rot_ang/99.99'] = {'max': 219.45210452032438, 'min': 140.54789547967562} # lost: 0
| gpl-3.0 |
lagopus/lagopus | test/ryu/vsw-602_mp_aggregate.py | 1 | 4108 | from ryu.base.app_manager import RyuApp
from ryu.controller.ofp_event import EventOFPSwitchFeatures
from ryu.controller.ofp_event import EventOFPAggregateStatsReply
from ryu.controller.handler import set_ev_cls
from ryu.controller.handler import CONFIG_DISPATCHER
from ryu.controller.handler import MAIN_DISPATCHER
from ryu.ofproto.ofproto_v1_2 import OFPG_ANY
from ryu.ofproto.ofproto_v1_3 import OFP_VERSION
from ryu.lib.mac import haddr_to_bin
class App(RyuApp):
OFP_VERSIONS = [OFP_VERSION]
def __init__(self, *args, **kwargs):
super(App, self).__init__(*args, **kwargs)
@set_ev_cls(EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
datapath = ev.msg.datapath
[self.install_sample(datapath, n) for n in [0]]
def create_match(self, parser, fields):
match = parser.OFPMatch()
for (field, value) in fields.iteritems():
match.append_field(field, value)
return match
def create_flow_mod(self, datapath, priority,
table_id, match, instructions):
ofproto = datapath.ofproto
flow_mod = datapath.ofproto_parser.OFPFlowMod(datapath, 0, 0, table_id,
ofproto.OFPFC_ADD, 0, 0,
priority,
ofproto.OFPCML_NO_BUFFER,
ofproto.OFPP_ANY,
OFPG_ANY, 0,
match, instructions)
return flow_mod
def install_sample(self, datapath, table_id):
parser = datapath.ofproto_parser
ofproto = datapath.ofproto
in_port = 1
eth_dst = '\x00' + '\x00' + '\x00' + '\x00' + '\x00' + '\x00'
self.logger.info("=== start : flow mod ===")
for i in range(1000):
match = self.create_match(parser,
{ofproto.OXM_OF_IN_PORT: in_port,
ofproto.OXM_OF_ETH_DST: eth_dst,
ofproto.OXM_OF_ETH_TYPE: 0x8847,
ofproto.OXM_OF_MPLS_LABEL: i})
popmpls = parser.OFPActionPopMpls(0x0800)
decttl = parser.OFPActionDecNwTtl()
pushvlan = parser.OFPActionPushVlan(0x8100)
setvlanid = parser.OFPActionSetField(vlan_vid=1)
setethsrc = parser.OFPActionSetField(eth_src='00:00:00:00:00:00')
setethdst = parser.OFPActionSetField(eth_dst='00:00:00:00:00:00')
output = parser.OFPActionOutput(2, 0)
write = parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
[popmpls, decttl, pushvlan,
setvlanid, setethsrc,
output])
instructions = [write]
flow_mod = self.create_flow_mod(datapath, 100, table_id,
match, instructions)
datapath.send_msg(flow_mod)
self.logger.info("=== end : flow mod ===")
cookie = cookie_mask = 0
match = parser.OFPMatch(in_port=1)
req = parser.OFPAggregateStatsRequest(datapath, 0,
ofproto.OFPTT_ALL,
ofproto.OFPP_ANY,
ofproto.OFPG_ANY,
cookie, cookie_mask,
match)
datapath.send_msg(req)
@set_ev_cls(EventOFPAggregateStatsReply, MAIN_DISPATCHER)
def aggregate_stats_reply_handler(self, ev):
body = ev.msg.body
self.logger.info('AggregateStats: packet_count=%d byte_count=%d '
'flow_count=%d',
body.packet_count, body.byte_count,
body.flow_count)
| apache-2.0 |
sudkannan/xen-hv | dist/install/usr/lib64/python2.6/site-packages/xen/xend/XendConstants.py | 13 | 4011 | #============================================================================
# This library is free software; you can redistribute it and/or
# modify it under the terms of version 2.1 of the GNU Lesser General Public
# License as published by the Free Software Foundation.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#============================================================================
# Copyright (C) 2006 XenSource Ltd.
#============================================================================
from xen.xend.XendAPIConstants import *
from xen.util import auxbin
#
# Shutdown codes and reasons.
#
DOMAIN_POWEROFF = 0
DOMAIN_REBOOT = 1
DOMAIN_SUSPEND = 2
DOMAIN_CRASH = 3
DOMAIN_HALT = 4
DOMAIN_SHUTDOWN_REASONS = {
DOMAIN_POWEROFF: "poweroff",
DOMAIN_REBOOT : "reboot",
DOMAIN_SUSPEND : "suspend",
DOMAIN_CRASH : "crash",
DOMAIN_HALT : "halt"
}
REVERSE_DOMAIN_SHUTDOWN_REASONS = \
dict([(y, x) for x, y in DOMAIN_SHUTDOWN_REASONS.items()])
HVM_PARAM_CALLBACK_IRQ = 0
HVM_PARAM_STORE_PFN = 1
HVM_PARAM_STORE_EVTCHN = 2
HVM_PARAM_PAE_ENABLED = 4
HVM_PARAM_IOREQ_PFN = 5
HVM_PARAM_BUFIOREQ_PFN = 6
HVM_PARAM_NVRAM_FD = 7 # ia64
HVM_PARAM_VHPT_SIZE = 8 # ia64
HVM_PARAM_BUFPIOREQ_PFN = 9 # ia64
HVM_PARAM_VIRIDIAN = 9 # x86
HVM_PARAM_TIMER_MODE = 10
HVM_PARAM_HPET_ENABLED = 11
HVM_PARAM_ACPI_S_STATE = 14
HVM_PARAM_VPT_ALIGN = 16
restart_modes = [
"restart",
"destroy",
"preserve",
"rename-restart",
"coredump-destroy",
"coredump-restart"
]
DOM_STATES = [
'halted',
'paused',
'running',
'suspended',
'shutdown',
'crashed',
'unknown',
]
DOM_STATE_HALTED = XEN_API_VM_POWER_STATE_HALTED
DOM_STATE_PAUSED = XEN_API_VM_POWER_STATE_PAUSED
DOM_STATE_RUNNING = XEN_API_VM_POWER_STATE_RUNNING
DOM_STATE_SUSPENDED = XEN_API_VM_POWER_STATE_SUSPENDED
DOM_STATE_SHUTDOWN = XEN_API_VM_POWER_STATE_SHUTTINGDOWN
DOM_STATE_CRASHED = XEN_API_VM_POWER_STATE_CRASHED
DOM_STATE_UNKNOWN = XEN_API_VM_POWER_STATE_UNKNOWN
DOM_STATES_OLD = [
'running',
'blocked',
'paused',
'shutdown',
'crashed',
'dying'
]
SHUTDOWN_TIMEOUT = (60.0 * 5)
"""Minimum time between domain restarts in seconds."""
MINIMUM_RESTART_TIME = 60
RESTART_IN_PROGRESS = 'xend/restart_in_progress'
DUMPCORE_IN_PROGRESS = 'xend/dumpcore_in_progress'
LAST_SHUTDOWN_REASON = 'xend/last_shutdown_reason'
TRIGGER_NMI = 0
TRIGGER_RESET = 1
TRIGGER_INIT = 2
TRIGGER_POWER = 3
TRIGGER_S3RESUME = 4
TRIGGER_TYPE = {
"nmi" : TRIGGER_NMI,
"reset" : TRIGGER_RESET,
"init" : TRIGGER_INIT,
"s3resume": TRIGGER_S3RESUME,
"power": TRIGGER_POWER
}
#
# Device migration stages (eg. XendDomainInfo, XendCheckpoint, server.tpmif)
#
DEV_MIGRATE_TEST = 0
DEV_MIGRATE_STEP1 = 1
DEV_MIGRATE_STEP2 = 2
DEV_MIGRATE_STEP3 = 3
#
# VTPM-related constants
#
VTPM_DELETE_SCRIPT = auxbin.scripts_dir() + '/vtpm-delete'
#
# Xenstore Constants
#
XS_VMROOT = "/vm/"
XS_POOLROOT = "/local/pool/"
NR_PCI_FUNC = 8
NR_PCI_DEV = 32
NR_PCI_DEVFN = NR_PCI_FUNC * NR_PCI_DEV
AUTO_PHP_SLOT = 0x100
#
# tmem
#
TMEM_CONTROL = 0
TMEM_NEW_POOL = 1
TMEM_DESTROY_POOL = 2
TMEM_NEW_PAGE = 3
TMEM_PUT_PAGE = 4
TMEM_GET_PAGE = 5
TMEM_FLUSH_PAGE = 6
TMEM_FLUSH_OBJECT = 7
TMEM_READ = 8
TMEM_WRITE = 9
TMEM_XCHG = 10
TMEMC_THAW = 0
TMEMC_FREEZE = 1
TMEMC_FLUSH = 2
TMEMC_DESTROY = 3
TMEMC_LIST = 4
TMEMC_SET_WEIGHT = 5
TMEMC_SET_CAP = 6
TMEMC_SET_COMPRESS = 7
TMEMC_QUERY_FREEABLE_MB = 8
| gpl-2.0 |
Alwnikrotikz/visvis.dev | vvmovie/images2ims.py | 8 | 7368 | # -*- coding: utf-8 -*-
# Copyright (C) 2012, Almar Klein
#
# This code is subject to the (new) BSD license:
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the <organization> nor the
# names of its contributors may be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""" Module images2ims
Use PIL to create a series of images.
"""
import os
try:
import numpy as np
except ImportError:
np = None
try:
import PIL
from PIL import Image
except ImportError:
PIL = None
def checkImages(images):
""" checkImages(images)
Check numpy images and correct intensity range etc.
The same for all movie formats.
"""
# Init results
images2 = []
for im in images:
if PIL and isinstance(im, PIL.Image.Image):
# We assume PIL images are allright
images2.append(im)
elif np and isinstance(im, np.ndarray):
# Check and convert dtype
if im.dtype == np.uint8:
images2.append(im) # Ok
elif im.dtype in [np.float32, np.float64]:
theMax = im.max()
if theMax > 128 and theMax < 300:
pass # assume 0:255
else:
im = im.copy()
im[im<0] = 0
im[im>1] = 1
im *= 255
images2.append( im.astype(np.uint8) )
else:
im = im.astype(np.uint8)
images2.append(im)
# Check size
if im.ndim == 2:
pass # ok
elif im.ndim == 3:
if im.shape[2] not in [3,4]:
raise ValueError('This array can not represent an image.')
else:
raise ValueError('This array can not represent an image.')
else:
raise ValueError('Invalid image type: ' + str(type(im)))
# Done
return images2
def _getFilenameParts(filename):
if '*' in filename:
return tuple( filename.split('*',1) )
else:
return os.path.splitext(filename)
def _getFilenameWithFormatter(filename, N):
# Determine sequence number formatter
formatter = '%04i'
if N < 10:
formatter = '%i'
elif N < 100:
formatter = '%02i'
elif N < 1000:
formatter = '%03i'
# Insert sequence number formatter
part1, part2 = _getFilenameParts(filename)
return part1 + formatter + part2
def _getSequenceNumber(filename, part1, part2):
# Get string bit
seq = filename[len(part1):-len(part2)]
# Get all numeric chars
seq2 = ''
for c in seq:
if c in '0123456789':
seq2 += c
else:
break
# Make int and return
return int(seq2)
def writeIms(filename, images):
""" writeIms(filename, images)
Export movie to a series of image files. If the filenenumber
contains an asterix, a sequence number is introduced at its
location. Otherwise the sequence number is introduced right
before the final dot.
To enable easy creation of a new directory with image files,
it is made sure that the full path exists.
Images should be a list consisting of PIL images or numpy arrays.
The latter should be between 0 and 255 for integer types, and
between 0 and 1 for float types.
"""
# Check PIL
if PIL is None:
raise RuntimeError("Need PIL to write series of image files.")
# Check images
images = checkImages(images)
# Get dirname and filename
filename = os.path.abspath(filename)
dirname, filename = os.path.split(filename)
# Create dir(s) if we need to
if not os.path.isdir(dirname):
os.makedirs(dirname)
# Insert formatter
filename = _getFilenameWithFormatter(filename, len(images))
# Write
seq = 0
for frame in images:
seq += 1
# Get filename
fname = os.path.join(dirname, filename%seq)
# Write image
if np and isinstance(frame, np.ndarray):
frame = PIL.Image.fromarray(frame)
frame.save(fname)
def readIms(filename, asNumpy=True):
""" readIms(filename, asNumpy=True)
Read images from a series of images in a single directory. Returns a
list of numpy arrays, or, if asNumpy is false, a list if PIL images.
"""
# Check PIL
if PIL is None:
raise RuntimeError("Need PIL to read a series of image files.")
# Check Numpy
if asNumpy and np is None:
raise RuntimeError("Need Numpy to return numpy arrays.")
# Get dirname and filename
filename = os.path.abspath(filename)
dirname, filename = os.path.split(filename)
# Check dir exists
if not os.path.isdir(dirname):
raise IOError('Directory not found: '+str(dirname))
# Get two parts of the filename
part1, part2 = _getFilenameParts(filename)
# Init images
images = []
# Get all files in directory
for fname in os.listdir(dirname):
if fname.startswith(part1) and fname.endswith(part2):
# Get sequence number
nr = _getSequenceNumber(fname, part1, part2)
# Get Pil image and store copy (to prevent keeping the file)
im = PIL.Image.open(os.path.join(dirname, fname))
images.append((im.copy(), nr))
# Sort images
images.sort(key=lambda x:x[1])
images = [im[0] for im in images]
# Convert to numpy if needed
if asNumpy:
images2 = images
images = []
for im in images2:
# Make without palette
if im.mode == 'P':
im = im.convert()
# Make numpy array
a = np.asarray(im)
if len(a.shape)==0:
raise MemoryError("Too little memory to convert PIL image to array")
# Add
images.append(a)
# Done
return images
| bsd-3-clause |
huiyi1990/Data-Structure-Zoo | 1-Algorithm Analysis/algorithms.py | 9 | 2193 | """ 2: Algorithms
thomas moll 2015
"""
import time, random
def find_sequentially(arr, item):
""" Sequential Search
Complexity: O(n)
"""
for value, i in enumerate(arr):
# Check each item in the list
if item == value: #Runs N number of times
return True
return False
def binary_search(arr, item):
""" Binary Search
Complexity: O(log(n))
Only works on sorted arrays
"""
first = 0
last = len(arr)-1
found = False
# Note that first and last will get closer!
while first <= last and not found:
# Divide problem set
mid = (first+last)//2
if arr[mid] == item:
found = True
else:
# Decide which half to search next
if item < arr[mid]:
last = mid - 1
else:
first = mid + 1
return found
def array_equals(a, b):
""" Checks to see that two arrays
are completely equal, regardless of order
Complexity: O(n^2)
"""
i = 0
# Check all values in A
while i < len(a): # This loop runs N times
flag = False
j = 0
# Search for that value in B
while j < len(b): # This loop runs N times
if a[i] == b[j]:
flag = True
break
j+=1
if not flag:
return False
i+=1
return True
# Below are some speed tests comparing sequential to binary search
if __name__ == '__main__':
print 'Given an array of a million ordered ints...'
big_o_list = list(xrange(1000000))
item = random.randint(0, 1000000)
print 'Finding',item,'using sequential search'
t0 = time.time()
find_sequentially(big_o_list, item)
t1 = time.time()
total = t1-t0
print 'Found',item,'in',total,'MS'
item = random.randint(0, 1000000)
print 'Finding',item,'using binary search'
t2 = time.time()
binary_search(big_o_list, item)
t3 = time.time()
total = t3-t2
print 'Found',item,'in',total,'MS'
| mit |
team-herring/herring-box | src/main/python/example/02.pingpong.py | 1 | 1361 | # -*- coding: utf-8 -*-
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import threading
import avro.ipc as ipc
import avro.protocol as protocol
import avro.schema as schema
import thread
PROTOCOL = protocol.parse(open("../../avro/pingpong.avpr").read())
server_addr = ('localhost', 9090)
class PingpongResponder(ipc.Responder):
def __init__(self):
ipc.Responder.__init__(self, PROTOCOL)
def invoke(self, msg, req):
if msg.name == 'send':
return "pong"
else:
raise schema.AvroException("unexpected message:", msg.getname())
class PingpongHandler(BaseHTTPRequestHandler):
def do_POST(self):
self.responder = PingpongResponder()
call_request_reader = ipc.FramedReader(self.rfile)
call_request = call_request_reader.read_framed_message()
resp_body = self.responder.respond(call_request)
print resp_body
self.send_response(200)
self.send_header('Content-Type', 'avro/binary')
self.end_headers()
resp_writer = ipc.FramedWriter(self.wfile)
resp_writer.write_framed_message(resp_body)
def start_server():
server = HTTPServer(server_addr, PingpongHandler)
server.allow_reuse_address = True
server.serve_forever()
if __name__ == '__main__':
thread.start_new_thread(start_server(), ())
| apache-2.0 |
admetricks/phantomjs | src/qt/qtwebkit/Tools/Scripts/webkitpy/tool/steps/applywatchlist.py | 132 | 2983 | # Copyright (C) 2011 Google Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from webkitpy.common.system import logutils
from webkitpy.tool.steps.abstractstep import AbstractStep
from webkitpy.tool.steps.options import Options
_log = logutils.get_logger(__file__)
class ApplyWatchList(AbstractStep):
@classmethod
def options(cls):
return AbstractStep.options() + [
Options.git_commit,
]
def run(self, state):
diff = self.cached_lookup(state, 'diff')
bug_id = state.get('bug_id')
cc_and_messages = self._tool.watch_list().determine_cc_and_messages(diff)
cc_emails = cc_and_messages['cc_list']
messages = cc_and_messages['messages']
if bug_id:
# Remove emails and cc's which are already in the bug or the reporter.
bug = self._tool.bugs.fetch_bug(bug_id)
messages = filter(lambda message: not bug.is_in_comments(message), messages)
cc_emails = set(cc_emails).difference(bug.cc_emails())
cc_emails.discard(bug.reporter_email())
comment_text = '\n\n'.join(messages)
if bug_id:
if cc_emails or comment_text:
self._tool.bugs.post_comment_to_bug(bug_id, comment_text, cc_emails)
log_result = _log.debug
else:
_log.info('No bug was updated because no id was given.')
log_result = _log.info
log_result('Result of watchlist: cc "%s" messages "%s"' % (', '.join(cc_emails), comment_text))
| bsd-3-clause |
willthames/ansible | lib/ansible/modules/network/nxos/nxos_vrf_interface.py | 7 | 9185 | #!/usr/bin/python
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
#
ANSIBLE_METADATA = {'metadata_version': '1.0',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
---
module: nxos_vrf_interface
extends_documentation_fragment: nxos
version_added: "2.1"
short_description: Manages interface specific VRF configuration.
description:
- Manages interface specific VRF configuration.
author:
- Jason Edelman (@jedelman8)
- Gabriele Gerbino (@GGabriele)
notes:
- VRF needs to be added globally with M(nxos_vrf) before
adding a VRF to an interface.
- Remove a VRF from an interface will still remove
all L3 attributes just as it does from CLI.
- VRF is not read from an interface until IP address is
configured on that interface.
options:
vrf:
description:
- Name of VRF to be managed.
required: true
interface:
description:
- Full name of interface to be managed, i.e. Ethernet1/1.
required: true
state:
description:
- Manages desired state of the resource.
required: false
default: present
choices: ['present','absent']
'''
EXAMPLES = '''
- name: Ensure vrf ntc exists on Eth1/1
nxos_vrf_interface:
vrf: ntc
interface: Ethernet1/1
host: 68.170.147.165
state: present
- name: Ensure ntc VRF does not exist on Eth1/1
nxos_vrf_interface:
vrf: ntc
interface: Ethernet1/1
host: 68.170.147.165
state: absent
'''
RETURN = '''
proposed:
description: k/v pairs of parameters passed into module
returned: always
type: dict
sample: {"interface": "loopback16", "vrf": "ntc"}
existing:
description: k/v pairs of existing vrf on the interface
returned: always
type: dict
sample: {"interface": "loopback16", "vrf": ""}
end_state:
description: k/v pairs of vrf after module execution
returned: always
type: dict
sample: {"interface": "loopback16", "vrf": "ntc"}
updates:
description: commands sent to the device
returned: always
type: list
sample: ["interface loopback16", "vrf member ntc"]
changed:
description: check to see if a change was made on the device
returned: always
type: boolean
sample: true
'''
import re
from ansible.module_utils.nxos import load_config, run_commands
from ansible.module_utils.nxos import nxos_argument_spec, check_args
from ansible.module_utils.basic import AnsibleModule
WARNINGS = []
def execute_show_command(command, module, command_type='cli_show'):
if 'show run' not in command:
output = 'json'
else:
output = 'text'
cmds = [{
'command': command,
'output': output,
}]
body = run_commands(module, cmds)
return body
def get_interface_type(interface):
if interface.upper().startswith('ET'):
return 'ethernet'
elif interface.upper().startswith('VL'):
return 'svi'
elif interface.upper().startswith('LO'):
return 'loopback'
elif interface.upper().startswith('MG'):
return 'management'
elif interface.upper().startswith('MA'):
return 'management'
elif interface.upper().startswith('PO'):
return 'portchannel'
else:
return 'unknown'
def get_interface_mode(interface, intf_type, module):
command = 'show interface {0}'.format(interface)
interface = {}
mode = 'unknown'
if intf_type in ['ethernet', 'portchannel']:
body = execute_show_command(command, module)[0]
interface_table = body['TABLE_interface']['ROW_interface']
mode = str(interface_table.get('eth_mode', 'layer3'))
if mode == 'access' or mode == 'trunk':
mode = 'layer2'
elif intf_type == 'loopback' or intf_type == 'svi':
mode = 'layer3'
return mode
def get_vrf_list(module):
command = 'show vrf all'
vrf_list = []
body = execute_show_command(command, module)[0]
try:
vrf_table = body['TABLE_vrf']['ROW_vrf']
except (KeyError, AttributeError):
return vrf_list
for each in vrf_table:
vrf_list.append(str(each['vrf_name']))
return vrf_list
def get_interface_info(interface, module):
if not interface.startswith('loopback'):
interface = interface.capitalize()
command = 'show run | section interface.{0}'.format(interface)
vrf_regex = ".*vrf\s+member\s+(?P<vrf>\S+).*"
try:
body = execute_show_command(command, module,
command_type='cli_show_ascii')[0]
match_vrf = re.match(vrf_regex, body, re.DOTALL)
group_vrf = match_vrf.groupdict()
vrf = group_vrf["vrf"]
except (AttributeError, TypeError):
return ""
return vrf
def is_default(interface, module):
command = 'show run interface {0}'.format(interface)
try:
body = execute_show_command(command, module,
command_type='cli_show_ascii')[0]
raw_list = body.split('\n')
if raw_list[-1].startswith('interface'):
return True
else:
return False
except (KeyError, IndexError):
return 'DNE'
def main():
argument_spec = dict(
vrf=dict(required=True),
interface=dict(type='str', required=True),
state=dict(default='present', choices=['present', 'absent'],
required=False),
include_defaults=dict(default=False),
config=dict(),
save=dict(type='bool', default=False)
)
argument_spec.update(nxos_argument_spec)
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
warnings = list()
check_args(module, warnings)
vrf = module.params['vrf']
interface = module.params['interface'].lower()
state = module.params['state']
current_vrfs = get_vrf_list(module)
if vrf not in current_vrfs:
WARNINGS.append("The VRF is not present/active on the device. "
"Use nxos_vrf to fix this.")
intf_type = get_interface_type(interface)
if (intf_type != 'ethernet' and module.params['transport'] == 'cli'):
if is_default(interface, module) == 'DNE':
module.fail_json(msg="interface does not exist on switch. Verify "
"switch platform or create it first with "
"nxos_interface if it's a logical interface")
mode = get_interface_mode(interface, intf_type, module)
if mode == 'layer2':
module.fail_json(msg='Ensure interface is a Layer 3 port before '
'configuring a VRF on an interface. You can '
'use nxos_interface')
proposed = dict(interface=interface, vrf=vrf)
current_vrf = get_interface_info(interface, module)
existing = dict(interface=interface, vrf=current_vrf)
changed = False
end_state = existing
if vrf != existing['vrf'] and state == 'absent':
module.fail_json(msg='The VRF you are trying to remove '
'from the interface does not exist '
'on that interface.',
interface=interface, proposed_vrf=vrf,
existing_vrf=existing['vrf'])
commands = []
if existing:
if state == 'absent':
if existing and vrf == existing['vrf']:
command = 'no vrf member {0}'.format(vrf)
commands.append(command)
elif state == 'present':
if existing['vrf'] != vrf:
command = 'vrf member {0}'.format(vrf)
commands.append(command)
if commands:
commands.insert(0, 'interface {0}'.format(interface))
if commands:
if module.check_mode:
module.exit_json(changed=True, commands=commands)
else:
load_config(module, commands)
changed = True
changed_vrf = get_interface_info(interface, module)
end_state = dict(interface=interface, vrf=changed_vrf)
if 'configure' in commands:
commands.pop(0)
results = {}
results['proposed'] = proposed
results['existing'] = existing
results['end_state'] = end_state
results['updates'] = commands
results['changed'] = changed
if WARNINGS:
results['warnings'] = WARNINGS
module.exit_json(**results)
if __name__ == '__main__':
main()
| gpl-3.0 |
SPriyaJain/studybuddy | env/lib/python2.7/site-packages/pip/_vendor/html5lib/treeadapters/sax.py | 1835 | 1661 | from __future__ import absolute_import, division, unicode_literals
from xml.sax.xmlreader import AttributesNSImpl
from ..constants import adjustForeignAttributes, unadjustForeignAttributes
prefix_mapping = {}
for prefix, localName, namespace in adjustForeignAttributes.values():
if prefix is not None:
prefix_mapping[prefix] = namespace
def to_sax(walker, handler):
"""Call SAX-like content handler based on treewalker walker"""
handler.startDocument()
for prefix, namespace in prefix_mapping.items():
handler.startPrefixMapping(prefix, namespace)
for token in walker:
type = token["type"]
if type == "Doctype":
continue
elif type in ("StartTag", "EmptyTag"):
attrs = AttributesNSImpl(token["data"],
unadjustForeignAttributes)
handler.startElementNS((token["namespace"], token["name"]),
token["name"],
attrs)
if type == "EmptyTag":
handler.endElementNS((token["namespace"], token["name"]),
token["name"])
elif type == "EndTag":
handler.endElementNS((token["namespace"], token["name"]),
token["name"])
elif type in ("Characters", "SpaceCharacters"):
handler.characters(token["data"])
elif type == "Comment":
pass
else:
assert False, "Unknown token type"
for prefix, namespace in prefix_mapping.items():
handler.endPrefixMapping(prefix)
handler.endDocument()
| mit |
forgeservicelab/ansible.inventory | sources/ssh_config.py | 1 | 4295 | #!/usr/bin/env python
# (c) 2014, Tomas Karasek <tomas.karasek@digile.fi>
#
# This file is part of Ansible.
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
# Dynamic inventory script which lets you use aliases from ~/.ssh/config.
#
# There were some issues with various Paramiko versions. I took a deeper look
# and tested heavily. Now, ansible parses this alright with Paramiko versions:
# 1.15.1 1.15.1 1.15.0 1.15.0 1.14.1 1.14.1 1.14.0 1.14.0 1.13.2
# 1.13.2 1.13.1 1.13.1 1.13.0 1.12.4 1.12.3 1.12.2 1.12.1 1.12.0
# 1.11.6 1.11.5 1.11.4 1.11.3 1.11.2 1.11.1 1.11.0 1.10.7 1.10.6
# 1.10.5 1.10.4 1.10.3 1.10.2 1.10.1 1.10.0 1.9.0 1.8.1 1.8.0
# 1.7.7.2 1.7.7.1 1.7.6 1.7.5 1.7.4 1.7.2
#
# It prints inventory based on parsed ~/.ssh/config. You can refer to hosts
# with their alias, rather than with the IP or hostname. It takes advantage
# of the ansible_ssh_{host,port,user,private_key_file}.
#
# If you have in your .ssh/config:
# Host git
# HostName git.domain.org
# User tkarasek
# IdentityFile /home/tomk/keys/thekey
#
# You can do
# $ ansible git -m ping
#
# Example invocation:
# ssh_config.py --list
# ssh_config.py --host <alias>
import argparse
import os.path
import sys
import paramiko
try:
import json
except ImportError:
import simplejson as json
SSH_CONF = '~/.ssh/config'
_key = 'ssh_config'
_ssh_to_ansible = [('user', 'ansible_ssh_user'),
('hostname', 'ansible_ssh_host'),
('identityfile', 'ansible_ssh_private_key_file'),
('port', 'ansible_ssh_port')]
def get_config():
if not os.path.isfile(os.path.expanduser(SSH_CONF)):
return {}
with open(os.path.expanduser(SSH_CONF)) as f:
cfg = paramiko.SSHConfig()
cfg.parse(f)
ret_dict = {}
for d in cfg._config:
if type(d['host']) is list:
alias = d['host'][0]
else:
alias = d['host']
if ('?' in alias) or ('*' in alias):
continue
_copy = dict(d)
del _copy['host']
if 'config' in _copy:
ret_dict[alias] = _copy['config']
else:
ret_dict[alias] = _copy
return ret_dict
def print_list():
cfg = get_config()
meta = {'hostvars': {}}
for alias, attributes in cfg.items():
tmp_dict = {}
for ssh_opt, ans_opt in _ssh_to_ansible:
if ssh_opt in attributes:
# If the attribute is a list, just take the first element.
# Private key is returned in a list for some reason.
attr = attributes[ssh_opt]
if type(attr) is list:
attr = attr[0]
tmp_dict[ans_opt] = attr
if tmp_dict:
meta['hostvars'][alias] = tmp_dict
print json.dumps({_key: list(set(meta['hostvars'].keys())), '_meta': meta})
def print_host(host):
cfg = get_config()
print json.dumps(cfg[host])
def get_args(args_list):
parser = argparse.ArgumentParser(
description='ansible inventory script parsing .ssh/config')
mutex_group = parser.add_mutually_exclusive_group(required=True)
help_list = 'list all hosts from .ssh/config inventory'
mutex_group.add_argument('--list', action='store_true', help=help_list)
help_host = 'display variables for a host'
mutex_group.add_argument('--host', help=help_host)
return parser.parse_args(args_list)
def main(args_list):
args = get_args(args_list)
if args.list:
print_list()
if args.host:
print_host(args.host)
if __name__ == '__main__':
main(sys.argv[1:])
| mit |
slightstone/SickRage | lib/requests/packages/chardet/sbcharsetprober.py | 2927 | 4793 | ######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Universal charset detector code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 2001
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
# Mark Pilgrim - port to Python
# Shy Shalom - original C code
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA
######################### END LICENSE BLOCK #########################
import sys
from . import constants
from .charsetprober import CharSetProber
from .compat import wrap_ord
SAMPLE_SIZE = 64
SB_ENOUGH_REL_THRESHOLD = 1024
POSITIVE_SHORTCUT_THRESHOLD = 0.95
NEGATIVE_SHORTCUT_THRESHOLD = 0.05
SYMBOL_CAT_ORDER = 250
NUMBER_OF_SEQ_CAT = 4
POSITIVE_CAT = NUMBER_OF_SEQ_CAT - 1
#NEGATIVE_CAT = 0
class SingleByteCharSetProber(CharSetProber):
def __init__(self, model, reversed=False, nameProber=None):
CharSetProber.__init__(self)
self._mModel = model
# TRUE if we need to reverse every pair in the model lookup
self._mReversed = reversed
# Optional auxiliary prober for name decision
self._mNameProber = nameProber
self.reset()
def reset(self):
CharSetProber.reset(self)
# char order of last character
self._mLastOrder = 255
self._mSeqCounters = [0] * NUMBER_OF_SEQ_CAT
self._mTotalSeqs = 0
self._mTotalChar = 0
# characters that fall in our sampling range
self._mFreqChar = 0
def get_charset_name(self):
if self._mNameProber:
return self._mNameProber.get_charset_name()
else:
return self._mModel['charsetName']
def feed(self, aBuf):
if not self._mModel['keepEnglishLetter']:
aBuf = self.filter_without_english_letters(aBuf)
aLen = len(aBuf)
if not aLen:
return self.get_state()
for c in aBuf:
order = self._mModel['charToOrderMap'][wrap_ord(c)]
if order < SYMBOL_CAT_ORDER:
self._mTotalChar += 1
if order < SAMPLE_SIZE:
self._mFreqChar += 1
if self._mLastOrder < SAMPLE_SIZE:
self._mTotalSeqs += 1
if not self._mReversed:
i = (self._mLastOrder * SAMPLE_SIZE) + order
model = self._mModel['precedenceMatrix'][i]
else: # reverse the order of the letters in the lookup
i = (order * SAMPLE_SIZE) + self._mLastOrder
model = self._mModel['precedenceMatrix'][i]
self._mSeqCounters[model] += 1
self._mLastOrder = order
if self.get_state() == constants.eDetecting:
if self._mTotalSeqs > SB_ENOUGH_REL_THRESHOLD:
cf = self.get_confidence()
if cf > POSITIVE_SHORTCUT_THRESHOLD:
if constants._debug:
sys.stderr.write('%s confidence = %s, we have a'
'winner\n' %
(self._mModel['charsetName'], cf))
self._mState = constants.eFoundIt
elif cf < NEGATIVE_SHORTCUT_THRESHOLD:
if constants._debug:
sys.stderr.write('%s confidence = %s, below negative'
'shortcut threshhold %s\n' %
(self._mModel['charsetName'], cf,
NEGATIVE_SHORTCUT_THRESHOLD))
self._mState = constants.eNotMe
return self.get_state()
def get_confidence(self):
r = 0.01
if self._mTotalSeqs > 0:
r = ((1.0 * self._mSeqCounters[POSITIVE_CAT]) / self._mTotalSeqs
/ self._mModel['mTypicalPositiveRatio'])
r = r * self._mFreqChar / self._mTotalChar
if r >= 1.0:
r = 0.99
return r
| gpl-3.0 |
davipeterlini/routeflow_tcc_ha | rflib/ipc/msgen.py | 8 | 15679 | import sys
messages = []
# C++
typesMap = {
"i8": "uint8_t",
"i32": "uint32_t",
"i64": "uint64_t",
"bool": "bool",
"ip": "IPAddress",
"mac": "MACAddress",
"string": "string",
"match": "Match&",
"match[]": "std::vector<Match>",
"action": "Action&",
"action[]": "std::vector<Action>",
"option": "Option&",
"option[]": "std::vector<Option>",
}
defaultValues = {
"i8": "0",
"i32": "0",
"i64": "0",
"bool": "false",
"ip": "IPAddress(IPV4)",
"mac": "MACAddress()",
"string": "\"\"",
"match[]": "std::vector<Match>()",
"action[]": "std::vector<Action>()",
"option[]": "std::vector<Option>()",
}
exportType = {
# Cast prevents C++ stringstreams from interpreting uint8_t as char
"i8": "to_string<uint16_t>({0})",
"i32": "to_string<uint32_t>({0})",
"i64": "to_string<uint64_t>({0})",
"bool": "{0}",
"ip": "{0}.toString()",
"mac": "{0}.toString()",
"string": "{0}",
"match[]": "MatchList::to_BSON({0})",
"action[]": "ActionList::to_BSON({0})",
"option[]": "OptionList::to_BSON({0})",
}
importType = {
"i8": "string_to<uint8_t>({0}.String())",
"i32": "string_to<uint32_t>({0}.String())",
"i64": "string_to<uint64_t>({0}.String())",
"bool": "{0}.Bool()",
"ip": "IPAddress(IPV4, {0}.String())",
"mac": "MACAddress({0}.String())",
"string": "{0}.String()",
"match[]": "MatchList::to_vector({0}.Array())",
"action[]": "ActionList::to_vector({0}.Array())",
"option[]": "OptionList::to_vector({0}.Array())",
}
# Python
pyTypesMap = {
"match" : "Match",
"action" : "Action",
"option" : "Option",
}
pyDefaultValues = {
"i8": "0",
"i32": "0",
"i64": "0",
"bool": "False",
"ip": "\"\"",
"mac": "\"\"",
"string": "\"\"",
"match[]": "list()",
"action[]": "list()",
"option[]": "list()",
}
pyExportType = {
"i8": "str({0})",
"i32": "str({0})",
"i64": "str({0})",
"bool": "bool({0})",
"ip": "str({0})",
"mac": "str({0})",
"string": "{0}",
"match[]": "{0}",
"action[]": "{0}",
"option[]": "{0}",
}
pyImportType = {
"i8": "int({0})",
"i32": "int({0})",
"i64": "int({0})",
"bool": "bool({0})",
"ip": "str({0})",
"mac": "str({0})",
"string": "str({0})",
"match[]": "list({0})",
"action[]": "list({0})",
"option[]": "list({0})",
}
def convmsgtype(string):
result = ""
i = 0
for char in string:
if char.isupper():
result += char
i += 1
else:
break
if i > 1:
result = result[:-1]
i -= 1
for char in string[i:]:
if char.isupper():
result += " " + char.lower()
else:
result += char.lower()
return result.replace(" ", "_").upper()
class CodeGenerator:
def __init__(self):
self.code = []
self.indentLevel = 0
def addLine(self, line):
indent = self.indentLevel * " "
self.code.append(indent + line)
def increaseIndent(self):
self.indentLevel += 1
def decreaseIndent(self):
self.indentLevel -= 1
def blankLine(self):
self.code.append("")
def __str__(self):
return "\n".join(self.code)
def genH(messages, fname):
g = CodeGenerator()
g.addLine("#ifndef __" + fname.upper() + "_H__")
g.addLine("#define __" + fname.upper() + "_H__")
g.blankLine();
g.addLine("#include <stdint.h>")
g.blankLine();
g.addLine("#include \"IPC.h\"")
g.addLine("#include \"IPAddress.h\"")
g.addLine("#include \"MACAddress.h\"")
g.addLine("#include \"converter.h\"")
g.addLine("#include \"Action.hh\"")
g.addLine("#include \"Match.hh\"")
g.addLine("#include \"Option.hh\"")
g.blankLine();
enum = "enum {\n\t"
enum += ",\n\t".join([convmsgtype(name) for name, msg in messages])
enum += "\n};"
g.addLine(enum);
g.blankLine();
for (name, msg) in messages:
g.addLine("class " + name + " : public IPCMessage {")
g.increaseIndent()
g.addLine("public:")
g.increaseIndent()
# Default constructor
g.addLine(name + "();")
# Constructor with parameters
g.addLine("{0}({1});".format(name, ", ".join([typesMap[t] + " " + f for t, f in msg])))
g.blankLine()
for t, f in msg:
g.addLine("{0} get_{1}();".format(typesMap[t], f))
g.addLine("void set_{0}({1} {2});".format(f, typesMap[t], f))
if t[-2:] == "[]":
t2 = t[0:-2]
g.addLine("void add_{0}(const {1} {0});".format(t2, typesMap[t2]))
g.blankLine()
g.addLine("virtual int get_type();")
g.addLine("virtual void from_BSON(const char* data);")
g.addLine("virtual const char* to_BSON();")
g.addLine("virtual string str();")
g.decreaseIndent();
g.blankLine()
g.addLine("private:")
g.increaseIndent()
for t, f in msg:
g.addLine("{0} {1};".format(typesMap[t], f))
g.decreaseIndent();
g.decreaseIndent();
g.addLine("};")
g.blankLine();
g.addLine("#endif /* __" + fname.upper() + "_H__ */")
return str(g)
def genCPP(messages, fname):
g = CodeGenerator()
g.addLine("#include \"{0}.h\"".format(fname))
g.blankLine()
g.addLine("#include <mongo/client/dbclient.h>")
g.blankLine()
for name, msg in messages:
g.addLine("{0}::{0}() {{".format(name))
g.increaseIndent();
for t, f in msg:
g.addLine("set_{0}({1});".format(f, defaultValues[t]))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
g.addLine("{0}::{0}({1}) {{".format(name, ", ".join([typesMap[t] + " " + f for t, f in msg])))
g.increaseIndent();
for t, f in msg:
g.addLine("set_{0}({1});".format(f, f))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
g.addLine("int {0}::get_type() {{".format(name))
g.increaseIndent();
g.addLine("return {0};".format(convmsgtype(name)))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
for t, f in msg:
g.addLine("{0} {1}::get_{2}() {{".format(typesMap[t], name, f))
g.increaseIndent();
g.addLine("return this->{0};".format(f))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
g.addLine("void {0}::set_{1}({2} {3}) {{".format(name, f, typesMap[t], f))
g.increaseIndent();
g.addLine("this->{0} = {1};".format(f, f))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
if t[-2:] == "[]":
t2 = t[0:-2]
g.addLine("void {0}::add_{1}(const {2} {1}) {{".format(name, t2, typesMap[t2]))
g.increaseIndent()
g.addLine("this->{0}.push_back({1});".format(f, t2))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
g.addLine("void {0}::from_BSON(const char* data) {{".format(name))
g.increaseIndent();
g.addLine("mongo::BSONObj obj(data);")
for t, f in msg:
value = "obj[\"{0}\"]".format(f)
g.addLine("set_{0}({1});".format(f, importType[t].format(value)))
g.decreaseIndent()
g.addLine("}")
g.blankLine();
g.addLine("const char* {0}::to_BSON() {{".format(name))
g.increaseIndent();
g.addLine("mongo::BSONObjBuilder _b;")
for t, f in msg:
value = "get_{0}()".format(f)
if t[-2:] == "[]":
g.addLine("_b.appendArray(\"{0}\", {1});".format(f, exportType[t].format(value)))
else:
g.addLine("_b.append(\"{0}\", {1});".format(f, exportType[t].format(value)))
g.addLine("mongo::BSONObj o = _b.obj();")
g.addLine("char* data = new char[o.objsize()];")
g.addLine("memcpy(data, o.objdata(), o.objsize());")
g.addLine("return data;");
g.decreaseIndent()
g.addLine("}")
g.blankLine();
g.addLine("string {0}::str() {{".format(name))
g.increaseIndent();
g.addLine("stringstream ss;")
g.addLine("ss << \"{0}\" << endl;".format(name))
for t, f in msg:
value = "get_{0}()".format(f)
g.addLine("ss << \" {0}: \" << {1} << endl;".format(f, exportType[t].format(value)))
g.addLine("return ss.str();")
g.decreaseIndent()
g.addLine("}")
g.blankLine();
return str(g)
def genHFactory(messages, fname):
g = CodeGenerator()
g.addLine("#ifndef __{0}FACTORY_H__".format(fname.upper()))
g.addLine("#define __{0}FACTORY_H__".format(fname.upper()))
g.blankLine()
g.addLine("#include \"IPC.h\"")
g.addLine("#include \"{0}.h\"".format(fname))
g.blankLine()
g.addLine("class {0}Factory : public IPCMessageFactory {1}".format(fname, "{"))
g.increaseIndent()
g.addLine("protected:")
g.increaseIndent()
g.addLine("IPCMessage* buildForType(int type);")
g.decreaseIndent()
g.decreaseIndent()
g.addLine("};");
g.blankLine()
g.addLine("#endif /* __{0}FACTORY_H__ */".format(fname.upper()))
g.blankLine()
return str(g)
def genCPPFactory(messages, fname):
g = CodeGenerator()
g.addLine("#include \"{0}Factory.h\"".format(fname))
g.blankLine()
g.addLine("IPCMessage* {0}Factory::buildForType(int type) {1}".format(fname, "{"))
g.increaseIndent()
g.addLine("switch (type) {0}".format("{"))
g.increaseIndent()
for name, msg in messages:
g.addLine("case {0}:".format(convmsgtype(name)))
g.increaseIndent()
g.addLine("return new {0}();".format(name))
g.decreaseIndent()
g.addLine("default:")
g.increaseIndent()
g.addLine("return NULL;")
g.decreaseIndent()
g.decreaseIndent()
g.addLine("}")
g.decreaseIndent()
g.addLine("}")
g.blankLine()
return str(g)
def genPy(messages, fname):
g = CodeGenerator()
g.addLine("import bson")
for tlv in ["Match","Action","Option"]:
g.addLine("from rflib.types.{0} import {0}".format(tlv))
g.addLine("from MongoIPC import MongoIPCMessage")
g.blankLine()
g.addLine("format_id = lambda dp_id: hex(dp_id).rstrip('L')")
g.blankLine()
v = 0
for name, msg in messages:
g.addLine("{0} = {1}".format(convmsgtype(name), v))
v += 1
g.blankLine()
for name, msg in messages:
g.blankLine()
g.addLine("class {0}(MongoIPCMessage):".format(name))
g.increaseIndent()
g.addLine("def __init__(self, {0}):".format(", ".join([f + "=None" for t, f in msg])))
g.increaseIndent()
for t, f in msg:
g.addLine("self.set_{0}({0})".format(f))
g.decreaseIndent()
g.blankLine();
g.addLine("def get_type(self):")
g.increaseIndent();
g.addLine("return {0}".format(convmsgtype(name)))
g.decreaseIndent()
g.blankLine();
for t, f in msg:
g.addLine("def get_{0}(self):".format(f))
g.increaseIndent();
g.addLine("return self.{0}".format(f))
g.decreaseIndent()
g.blankLine();
g.addLine("def set_{0}(self, {0}):".format(f))
g.increaseIndent();
g.addLine("{0} = {1} if {0} is None else {0}".format(f, pyDefaultValues[t]))
g.addLine("try:")
g.increaseIndent()
g.addLine("self.{0} = {1}".format(f, pyImportType[t].format(f)))
g.decreaseIndent()
g.addLine("except:")
g.increaseIndent()
g.addLine("self.{0} = {1}".format(f, pyDefaultValues[t]))
g.decreaseIndent()
g.decreaseIndent()
g.blankLine();
if t[-2:] == "[]":
t2 = t[0:-2]
g.addLine("def add_{0}(self, {0}):".format(t2))
g.increaseIndent()
g.addLine("self.{0}.append({1}.to_dict())".format(f, t2))
g.decreaseIndent()
g.blankLine();
g.addLine("def from_dict(self, data):")
g.increaseIndent();
for t, f in msg:
g.addLine("self.set_{0}(data[\"{0}\"])".format(f))
g.decreaseIndent()
g.blankLine();
g.addLine("def to_dict(self):")
g.increaseIndent();
g.addLine("data = {}")
for t, f in msg:
value = pyExportType[t].format("self.get_{0}()".format(f))
g.addLine("data[\"{0}\"] = {1}".format(f, value))
g.addLine("return data")
g.decreaseIndent()
g.blankLine();
g.addLine("def from_bson(self, data):")
g.increaseIndent()
g.addLine("data = bson.BSON.decode(data)")
g.addLine("self.from_dict(data)")
g.decreaseIndent()
g.blankLine()
g.addLine("def to_bson(self):")
g.increaseIndent()
g.addLine("return bson.BSON.encode(self.get_dict())")
g.decreaseIndent()
g.blankLine()
g.addLine("def __str__(self):")
g.increaseIndent();
g.addLine("s = \"{0}\\n\"".format(name))
for t, f in msg:
value = "self.get_{0}()".format(f)
if t[-2:] == "[]":
g.addLine("s += \" {0}:\\n\"".format(f))
g.addLine("for {0} in {1}:".format(t[:-2], value))
g.increaseIndent()
g.addLine("s += \" \" + str({0}.from_dict({1})) + \"\\n\"".format(pyTypesMap[t[:-2]], t[:-2]))
g.decreaseIndent()
elif t == "i64":
g.addLine("s += \" {0}: \" + format_id({1}) + \"\\n\"".format(f, value))
else:
g.addLine("s += \" {0}: \" + str({1}) + \"\\n\"".format(f, value))
g.addLine("return s")
g.decreaseIndent()
g.decreaseIndent()
g.blankLine();
return str(g)
def genPyFactory(messages, fname):
g = CodeGenerator()
g.addLine("import rflib.ipc.IPC as IPC")
g.addLine("from rflib.ipc.{0} import *".format(fname))
g.blankLine()
g.addLine("class {0}Factory(IPC.IPCMessageFactory):".format(fname))
g.increaseIndent()
g.addLine("def build_for_type(self, type_):")
g.increaseIndent()
for name, msg in messages:
g.addLine("if type_ == {0}:".format(convmsgtype(name)))
g.increaseIndent()
g.addLine("return {0}()".format(name))
g.decreaseIndent()
g.decreaseIndent()
g.decreaseIndent()
g.blankLine()
return str(g)
# Text processing
fname = sys.argv[1]
f = open(fname, "r")
currentMessage = None
lines = [line.rstrip("\n") for line in f.readlines()]
f.close()
i = 0
for line in lines:
parts = line.split()
if len(parts) == 0:
continue
elif len(parts) == 1:
currentMessage = parts[0]
messages.append((currentMessage, []))
elif len(parts) == 2:
if currentMessage is None:
print "Error: message not declared"
messages[-1][1].append((parts[0], parts[1]))
else:
print "Error: invalid line"
f = open(fname + ".h", "w")
f.write(genH(messages, fname))
f.close()
f = open(fname + ".cc", "w")
f.write(genCPP(messages, fname))
f.close()
f = open(fname + "Factory.h", "w")
f.write(genHFactory(messages, fname))
f.close()
f = open(fname + "Factory.cc", "w")
f.write(genCPPFactory(messages, fname))
f.close()
f = open(fname + ".py", "w")
f.write(genPy(messages, fname))
f.close()
f = open(fname + "Factory.py", "w")
f.write(genPyFactory(messages, fname))
f.close()
| apache-2.0 |
Project-OSRM/osrm-backend | third_party/flatbuffers/tests/namespace_test/NamespaceC/TableInC.py | 28 | 1610 | # automatically generated by the FlatBuffers compiler, do not modify
# namespace: NamespaceC
import flatbuffers
class TableInC(object):
__slots__ = ['_tab']
@classmethod
def GetRootAsTableInC(cls, buf, offset):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TableInC()
x.Init(buf, n + offset)
return x
# TableInC
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# TableInC
def ReferToA1(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from .TableInFirstNS import TableInFirstNS
obj = TableInFirstNS()
obj.Init(self._tab.Bytes, x)
return obj
return None
# TableInC
def ReferToA2(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
if o != 0:
x = self._tab.Indirect(o + self._tab.Pos)
from .SecondTableInA import SecondTableInA
obj = SecondTableInA()
obj.Init(self._tab.Bytes, x)
return obj
return None
def TableInCStart(builder): builder.StartObject(2)
def TableInCAddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0)
def TableInCAddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0)
def TableInCEnd(builder): return builder.EndObject()
| bsd-2-clause |
grapo/django-rest-framework-json-api | rest_framework_json_api/renderers.py | 2 | 4458 | """
Renderers
"""
from collections import OrderedDict
from rest_framework import renderers
from . import utils
class JSONRenderer(renderers.JSONRenderer):
"""
Render a JSON response per the JSON API spec:
{
"data": [{
"type": "companies",
"id": 1,
"attributes": {
"name": "Mozilla",
"slug": "mozilla",
"date-created": "2014-03-13 16:33:37"
}
}, {
"type": "companies",
"id": 2,
...
}]
}
"""
media_type = 'application/vnd.api+json'
format = 'vnd.api+json'
def render(self, data, accepted_media_type=None, renderer_context=None):
# Get the resource name.
resource_name = utils.get_resource_name(renderer_context)
view = renderer_context.get("view", None)
request = renderer_context.get("request", None)
# If `resource_name` is set to None then render default as the dev
# wants to build the output format manually.
if resource_name is None or resource_name is False:
return super(JSONRenderer, self).render(
data, accepted_media_type, renderer_context
)
# If this is an error response, skip the rest.
if resource_name == 'errors':
if len(data) > 1 and isinstance(data, list):
data.sort(key=lambda x: x.get('source', {}).get('pointer', ''))
return super(JSONRenderer, self).render(
{resource_name: data}, accepted_media_type, renderer_context
)
json_api_included = list()
# If detail view then json api spec expects dict, otherwise a list
# - http://jsonapi.org/format/#document-top-level
# The `results` key may be missing if unpaginated or an OPTIONS request
if view and hasattr(view, 'action') and view.action == 'list' and \
isinstance(data, dict) and 'results' in data:
results = data["results"]
resource_serializer = results.serializer
# Get the serializer fields
fields = utils.get_serializer_fields(resource_serializer)
json_api_data = list()
for position in range(len(results)):
resource = results[position] # Get current resource
resource_instance = resource_serializer.instance[position] # Get current instance
json_api_data.append(
utils.build_json_resource_obj(fields, resource, resource_instance, resource_name))
included = utils.extract_included(fields, resource, resource_instance)
if included:
json_api_included.extend(included)
else:
# Check if data contains a serializer
if hasattr(data, 'serializer'):
fields = utils.get_serializer_fields(data.serializer)
resource_instance = data.serializer.instance
json_api_data = utils.build_json_resource_obj(fields, data, resource_instance, resource_name)
included = utils.extract_included(fields, data, resource_instance)
if included:
json_api_included.extend(included)
else:
json_api_data = data
# Make sure we render data in a specific order
render_data = OrderedDict()
if isinstance(data, dict) and data.get('links'):
render_data['links'] = data.get('links')
render_data['data'] = json_api_data
if len(json_api_included) > 0:
# Iterate through compound documents to remove duplicates
seen = set()
unique_compound_documents = list()
for included_dict in json_api_included:
type_tuple = tuple((included_dict['type'], included_dict['id']))
if type_tuple not in seen:
seen.add(type_tuple)
unique_compound_documents.append(included_dict)
# Sort the items by type then by id
render_data['included'] = sorted(unique_compound_documents, key=lambda item: (item['type'], item['id']))
if isinstance(data, dict) and data.get('meta'):
render_data['meta'] = data.get('meta')
return super(JSONRenderer, self).render(
render_data, accepted_media_type, renderer_context
)
| bsd-2-clause |
YOTOV-LIMITED/kitsune | kitsune/questions/tests/test_api.py | 11 | 26745 | import json
from datetime import datetime, timedelta
import mock
import actstream.actions
from actstream.models import Follow
from nose.tools import eq_, ok_, raises
from rest_framework.test import APIClient
from rest_framework.exceptions import APIException
from taggit.models import Tag
from kitsune.sumo.tests import TestCase
from kitsune.questions import api
from kitsune.questions.models import Question, Answer
from kitsune.questions.tests import question, answer, questionvote, answervote
from kitsune.products.tests import product, topic
from kitsune.sumo.urlresolvers import reverse
from kitsune.users.helpers import profile_avatar
from kitsune.users.models import Profile
from kitsune.users.tests import profile, user, add_permission
class TestQuestionSerializerDeserialization(TestCase):
def setUp(self):
self.profile = profile()
self.product = product(save=True)
self.topic = topic(product=self.product, save=True)
self.request = mock.Mock()
self.request.user = self.profile.user
self.context = {
'request': self.request,
}
self.data = {
'creator': self.profile,
'title': 'How do I test programs?',
'content': "Help, I don't know what to do.",
'product': self.product.slug,
'topic': self.topic.slug,
}
def test_it_works(self):
serializer = api.QuestionSerializer(
context=self.context, data=self.data)
eq_(serializer.errors, {})
ok_(serializer.is_valid())
def test_automatic_creator(self):
del self.data['creator']
serializer = api.QuestionSerializer(
context=self.context, data=self.data)
eq_(serializer.errors, {})
ok_(serializer.is_valid())
eq_(serializer.object.creator, self.profile.user)
def test_product_required(self):
del self.data['product']
serializer = api.QuestionSerializer(
context=self.context, data=self.data)
eq_(serializer.errors, {
'product': [u'This field is required.'],
'topic': [u'A product must be specified to select a topic.'],
})
ok_(not serializer.is_valid())
def test_topic_required(self):
del self.data['topic']
serializer = api.QuestionSerializer(
context=self.context, data=self.data)
eq_(serializer.errors, {
'topic': [u'This field is required.'],
})
ok_(not serializer.is_valid())
def test_topic_disambiguation(self):
# First make another product, and a colliding topic.
# It has the same slug, but a different product.
new_product = product(save=True)
topic(product=new_product, slug=self.topic.slug, save=True)
serializer = api.QuestionSerializer(
context=self.context, data=self.data)
eq_(serializer.errors, {})
ok_(serializer.is_valid())
eq_(serializer.object.topic, self.topic)
def test_solution_is_readonly(self):
q = question(save=True)
a = answer(question=q, save=True)
self.data['solution'] = a.id
serializer = api.QuestionSerializer(context=self.context, data=self.data, instance=q)
serializer.save()
eq_(q.solution, None)
class TestQuestionSerializerSerialization(TestCase):
def setUp(self):
self.asker = profile().user
self.helper1 = profile().user
self.helper2 = profile().user
self.question = question(creator=self.asker, save=True)
def _names(self, *users):
return sorted(
{
'username': u.username,
'display_name': Profile.objects.get(user=u).name,
'avatar': profile_avatar(u),
}
for u in users)
def _answer(self, user):
return answer(question=self.question, creator=user, save=True)
def test_no_votes(self):
serializer = api.QuestionSerializer(instance=self.question)
eq_(serializer.data['num_votes'], 0)
def test_with_votes(self):
questionvote(question=self.question, save=True)
questionvote(question=self.question, save=True)
questionvote(save=True)
serializer = api.QuestionSerializer(instance=self.question)
eq_(serializer.data['num_votes'], 2)
def test_just_asker(self):
serializer = api.QuestionSerializer(instance=self.question)
eq_(serializer.data['involved'], self._names(self.asker))
def test_one_answer(self):
self._answer(self.helper1)
serializer = api.QuestionSerializer(instance=self.question)
eq_(sorted(serializer.data['involved']), self._names(self.asker, self.helper1))
def test_asker_and_response(self):
self._answer(self.helper1)
self._answer(self.asker)
serializer = api.QuestionSerializer(instance=self.question)
eq_(sorted(serializer.data['involved']), self._names(self.asker, self.helper1))
def test_asker_and_two_answers(self):
self._answer(self.helper1)
self._answer(self.asker)
self._answer(self.helper2)
serializer = api.QuestionSerializer(instance=self.question)
eq_(sorted(serializer.data['involved']),
self._names(self.asker, self.helper1, self.helper2))
def test_solution_is_id(self):
a = self._answer(self.helper1)
self.question.solution = a
self.question.save()
serializer = api.QuestionSerializer(instance=self.question)
eq_(serializer.data['solution'], a.id)
def test_creator_is_object(self):
serializer = api.QuestionSerializer(instance=self.question)
eq_(serializer.data['creator'], {
'username': self.question.creator.username,
'display_name': Profile.objects.get(user=self.question.creator).display_name,
'avatar': profile_avatar(self.question.creator),
})
class TestQuestionViewSet(TestCase):
def setUp(self):
self.client = APIClient()
def test_create(self):
u = profile().user
p = product(save=True)
t = topic(product=p, save=True)
self.client.force_authenticate(user=u)
data = {
'title': 'How do I start Firefox?',
'content': 'Seriously, what do I do?',
'product': p.slug,
'topic': t.slug,
}
eq_(Question.objects.count(), 0)
res = self.client.post(reverse('question-list'), data)
eq_(res.status_code, 201)
eq_(Question.objects.count(), 1)
q = Question.objects.all()[0]
eq_(q.title, data['title'])
eq_(q.content, data['content'])
eq_(q.content_parsed, res.data['content'])
def test_delete_permissions(self):
u1 = user(save=True)
u2 = user(save=True)
q = question(creator=u1, save=True)
# Anonymous user can't delete
self.client.force_authenticate(user=None)
res = self.client.delete(reverse('question-detail', args=[q.id]))
eq_(res.status_code, 401) # Unauthorized
# Non-owner can't delete
self.client.force_authenticate(user=u2)
res = self.client.delete(reverse('question-detail', args=[q.id]))
eq_(res.status_code, 403) # Forbidden
# Owner can delete
self.client.force_authenticate(user=u1)
res = self.client.delete(reverse('question-detail', args=[q.id]))
eq_(res.status_code, 204) # No content
def test_solve(self):
q = question(save=True)
a = answer(question=q, save=True)
self.client.force_authenticate(user=q.creator)
res = self.client.post(reverse('question-solve', args=[q.id]),
data={'answer': a.id})
eq_(res.status_code, 204)
q = Question.objects.get(id=q.id)
eq_(q.solution, a)
def test_filter_is_taken_true(self):
q1 = question(save=True)
q2 = question(save=True)
q2.take(q1.creator)
url = reverse('question-list') + '?is_taken=1'
res = self.client.get(url)
eq_(res.status_code, 200)
eq_(res.data['count'], 1)
eq_(res.data['results'][0]['id'], q2.id)
def test_filter_is_taken_false(self):
q1 = question(save=True)
q2 = question(save=True)
q2.take(q1.creator)
url = reverse('question-list') + '?is_taken=0'
res = self.client.get(url)
eq_(res.status_code, 200)
eq_(res.data['count'], 1)
eq_(res.data['results'][0]['id'], q1.id)
def test_filter_is_taken_expired(self):
q = question(save=True)
# "take" the question, but with an expired timer.
q.taken_by = profile().user
q.taken_until = datetime.now() - timedelta(seconds=60)
url = reverse('question-list') + '?is_taken=1'
res = self.client.get(url)
eq_(res.status_code, 200)
eq_(res.data['count'], 0)
def test_filter_taken_by_username(self):
q1 = question(save=True)
q2 = question(save=True)
q2.take(q1.creator)
url = reverse('question-list') + '?taken_by=' + q1.creator.username
res = self.client.get(url)
eq_(res.status_code, 200)
eq_(res.data['count'], 1)
eq_(res.data['results'][0]['id'], q2.id)
def test_helpful(self):
q = question(save=True)
u = profile().user
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-helpful', args=[q.id]))
eq_(res.status_code, 200)
eq_(res.data, {'num_votes': 1})
eq_(Question.objects.get(id=q.id).num_votes, 1)
def test_helpful_double_vote(self):
q = question(save=True)
u = profile().user
questionvote(question=q, creator=u, save=True)
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-helpful', args=[q.id]))
eq_(res.status_code, 409)
# It's 1, not 0, because one was created above. The failure cause is
# if the number of votes is 2, one from above and one from the api call.
eq_(Question.objects.get(id=q.id).num_votes, 1)
def test_helpful_question_not_editable(self):
q = question(is_locked=True, save=True)
u = profile().user
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-helpful', args=[q.id]))
eq_(res.status_code, 403)
eq_(Question.objects.get(id=q.id).num_votes, 0)
def test_ordering(self):
q1 = question(save=True)
q2 = question(save=True)
res = self.client.get(reverse('question-list'))
eq_(res.data['results'][0]['id'], q2.id)
eq_(res.data['results'][1]['id'], q1.id)
res = self.client.get(reverse('question-list') + '?ordering=id')
eq_(res.data['results'][0]['id'], q1.id)
eq_(res.data['results'][1]['id'], q2.id)
res = self.client.get(reverse('question-list') + '?ordering=-id')
eq_(res.data['results'][0]['id'], q2.id)
eq_(res.data['results'][1]['id'], q1.id)
def test_filter_product_with_slug(self):
p1 = product(save=True)
p2 = product(save=True)
q1 = question(product=p1, save=True)
question(product=p2, save=True)
querystring = '?product={0}'.format(p1.slug)
res = self.client.get(reverse('question-list') + querystring)
eq_(len(res.data['results']), 1)
eq_(res.data['results'][0]['id'], q1.id)
def test_filter_creator_with_username(self):
q1 = question(save=True)
question(save=True)
querystring = '?creator={0}'.format(q1.creator.username)
res = self.client.get(reverse('question-list') + querystring)
eq_(res.status_code, 200)
eq_(len(res.data['results']), 1)
eq_(res.data['results'][0]['id'], q1.id)
def test_filter_involved(self):
q1 = question(save=True)
a1 = answer(question=q1, save=True)
q2 = question(creator=a1.creator, save=True)
querystring = '?involved={0}'.format(q1.creator.username)
res = self.client.get(reverse('question-list') + querystring)
eq_(res.status_code, 200)
eq_(len(res.data['results']), 1)
eq_(res.data['results'][0]['id'], q1.id)
querystring = '?involved={0}'.format(q2.creator.username)
res = self.client.get(reverse('question-list') + querystring)
eq_(res.status_code, 200)
eq_(len(res.data['results']), 2)
# The API has a default sort, so ordering will be consistent.
eq_(res.data['results'][0]['id'], q2.id)
eq_(res.data['results'][1]['id'], q1.id)
def test_is_taken(self):
q = question(save=True)
u = profile().user
q.take(u)
url = reverse('question-detail', args=[q.id])
res = self.client.get(url)
eq_(res.status_code, 200)
eq_(res.data['taken_by']['username'], u.username)
def test_take(self):
q = question(save=True)
u = user(save=True)
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-take', args=[q.id]))
eq_(res.status_code, 204)
q = Question.objects.get(id=q.id)
eq_(q.taken_by, u)
def test_take_by_owner(self):
q = question(save=True)
self.client.force_authenticate(user=q.creator)
res = self.client.post(reverse('question-take', args=[q.id]))
eq_(res.status_code, 400)
q = Question.objects.get(id=q.id)
eq_(q.taken_by, None)
def test_take_conflict(self):
u1 = user(save=True)
u2 = user(save=True)
taken_until = datetime.now() + timedelta(seconds=30)
q = question(save=True, taken_until=taken_until, taken_by=u1)
self.client.force_authenticate(user=u2)
res = self.client.post(reverse('question-take', args=[q.id]))
eq_(res.status_code, 409)
q = Question.objects.get(id=q.id)
eq_(q.taken_by, u1)
def test_follow(self):
q = question(save=True)
u = profile().user
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-follow', args=[q.id]))
eq_(res.status_code, 204)
f = Follow.objects.get(user=u)
eq_(f.follow_object, q)
eq_(f.actor_only, False)
def test_unfollow(self):
q = question(save=True)
u = profile().user
actstream.actions.follow(u, q, actor_only=False)
eq_(Follow.objects.filter(user=u).count(), 1) # pre-condition
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-unfollow', args=[q.id]))
eq_(res.status_code, 204)
eq_(Follow.objects.filter(user=u).count(), 0)
def test_add_tags(self):
q = question(save=True)
eq_(0, q.tags.count())
u = profile().user
add_permission(u, Tag, 'add_tag')
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-add-tags', args=[q.id]),
content_type='application/json',
data=json.dumps({'tags': ['test', 'more', 'tags']}))
eq_(res.status_code, 200)
eq_(3, q.tags.count())
def test_remove_tags(self):
q = question(save=True)
q.tags.add('test')
q.tags.add('more')
q.tags.add('tags')
eq_(3, q.tags.count())
u = profile().user
self.client.force_authenticate(user=u)
res = self.client.post(reverse('question-remove-tags', args=[q.id]),
content_type='application/json',
data=json.dumps({'tags': ['more', 'tags']}))
eq_(res.status_code, 204)
eq_(1, q.tags.count())
def test_bleaching(self):
"""Tests whether question content is bleached."""
q = question(content=u'<unbleached>Cupcakes are the best</unbleached>', save=True)
url = reverse('question-detail', args=[q.id])
res = self.client.get(url)
eq_(res.status_code, 200)
assert '<unbleached>' not in res.data['content']
class TestAnswerSerializerDeserialization(TestCase):
def test_no_votes(self):
a = answer(save=True)
serializer = api.AnswerSerializer(instance=a)
eq_(serializer.data['num_helpful_votes'], 0)
eq_(serializer.data['num_unhelpful_votes'], 0)
def test_with_votes(self):
a = answer(save=True)
answervote(answer=a, helpful=True, save=True)
answervote(answer=a, helpful=True, save=True)
answervote(answer=a, helpful=False, save=True)
answervote(save=True)
serializer = api.AnswerSerializer(instance=a)
eq_(serializer.data['num_helpful_votes'], 2)
eq_(serializer.data['num_unhelpful_votes'], 1)
class TestAnswerViewSet(TestCase):
def setUp(self):
self.client = APIClient()
def test_create(self):
q = question(save=True)
u = profile().user
self.client.force_authenticate(user=u)
data = {
'question': q.id,
'content': 'You just need to click the fox.',
}
eq_(Answer.objects.count(), 0)
res = self.client.post(reverse('answer-list'), data)
eq_(res.status_code, 201)
eq_(Answer.objects.count(), 1)
a = Answer.objects.all()[0]
eq_(a.content, data['content'])
eq_(a.content_parsed, res.data['content'])
eq_(a.question, q)
def test_delete_permissions(self):
u1 = user(save=True)
u2 = user(save=True)
a = answer(creator=u1, save=True)
# Anonymous user can't delete
self.client.force_authenticate(user=None)
res = self.client.delete(reverse('answer-detail', args=[a.id]))
eq_(res.status_code, 401) # Unauthorized
# Non-owner can't deletea
self.client.force_authenticate(user=u2)
res = self.client.delete(reverse('answer-detail', args=[a.id]))
eq_(res.status_code, 403) # Forbidden
# Owner can delete
self.client.force_authenticate(user=u1)
res = self.client.delete(reverse('answer-detail', args=[a.id]))
eq_(res.status_code, 204) # No content
def test_ordering(self):
a1 = answer(save=True)
a2 = answer(save=True)
res = self.client.get(reverse('answer-list'))
eq_(res.data['results'][0]['id'], a2.id)
eq_(res.data['results'][1]['id'], a1.id)
res = self.client.get(reverse('answer-list') + '?ordering=id')
eq_(res.data['results'][0]['id'], a1.id)
eq_(res.data['results'][1]['id'], a2.id)
res = self.client.get(reverse('answer-list') + '?ordering=-id')
eq_(res.data['results'][0]['id'], a2.id)
eq_(res.data['results'][1]['id'], a1.id)
def test_helpful(self):
a = answer(save=True)
u = profile().user
self.client.force_authenticate(user=u)
res = self.client.post(reverse('answer-helpful', args=[a.id]))
eq_(res.status_code, 200)
eq_(res.data, {'num_helpful_votes': 1, 'num_unhelpful_votes': 0})
eq_(Answer.objects.get(id=a.id).num_votes, 1)
def test_helpful_double_vote(self):
a = answer(save=True)
u = profile().user
answervote(answer=a, creator=u, save=True)
self.client.force_authenticate(user=u)
res = self.client.post(reverse('answer-helpful', args=[a.id]))
eq_(res.status_code, 409)
# It's 1, not 0, because one was created above. The failure cause is
# if the number of votes is 2, one from above and one from the api call.
eq_(Answer.objects.get(id=a.id).num_votes, 1)
def test_helpful_answer_not_editable(self):
q = question(is_locked=True, save=True)
a = answer(question=q, save=True)
u = profile().user
self.client.force_authenticate(user=u)
res = self.client.post(reverse('answer-helpful', args=[a.id]))
eq_(res.status_code, 403)
eq_(Answer.objects.get(id=a.id).num_votes, 0)
def test_follow(self):
a = answer(save=True)
u = profile().user
self.client.force_authenticate(user=u)
eq_(Follow.objects.filter(user=u).count(), 0) # pre-condition
res = self.client.post(reverse('answer-follow', args=[a.id]))
eq_(res.status_code, 204)
f = Follow.objects.get(user=u)
eq_(f.follow_object, a)
eq_(f.actor_only, False)
def test_unfollow(self):
a = answer(save=True)
u = profile().user
actstream.actions.follow(u, a, actor_only=False)
eq_(Follow.objects.filter(user=u).count(), 1) # pre-condition
self.client.force_authenticate(user=u)
res = self.client.post(reverse('answer-unfollow', args=[a.id]))
eq_(res.status_code, 204)
eq_(Follow.objects.filter(user=u).count(), 0)
def test_bleaching(self):
"""Tests whether answer content is bleached."""
a = answer(content=u'<unbleached>Cupcakes are the best</unbleached>', save=True)
url = reverse('answer-detail', args=[a.id])
res = self.client.get(url)
eq_(res.status_code, 200)
assert '<unbleached>' not in res.data['content']
class TestQuestionFilter(TestCase):
def setUp(self):
self.filter_instance = api.QuestionFilter()
self.queryset = Question.objects.all()
def filter(self, filter_data):
return self.filter_instance.filter_metadata(self.queryset, json.dumps(filter_data))
def test_filter_involved(self):
q1 = question(save=True)
a1 = answer(question=q1, save=True)
q2 = question(creator=a1.creator, save=True)
qs = self.filter_instance.filter_involved(self.queryset, q1.creator.username)
eq_(list(qs), [q1])
qs = self.filter_instance.filter_involved(self.queryset, q2.creator.username)
# The filter does not have a strong order.
qs = sorted(qs, key=lambda q: q.id)
eq_(qs, [q1, q2])
def test_filter_is_solved(self):
q1 = question(save=True)
a1 = answer(question=q1, save=True)
q1.solution = a1
q1.save()
q2 = question(save=True)
qs = self.filter_instance.filter_is_solved(self.queryset, True)
eq_(list(qs), [q1])
qs = self.filter_instance.filter_is_solved(self.queryset, False)
eq_(list(qs), [q2])
def test_filter_solved_by(self):
q1 = question(save=True)
a1 = answer(question=q1, save=True)
q1.solution = a1
q1.save()
q2 = question(save=True)
answer(question=q2, creator=a1.creator, save=True)
q3 = question(save=True)
a3 = answer(question=q3, save=True)
q3.solution = a3
q3.save()
qs = self.filter_instance.filter_solved_by(self.queryset, a1.creator.username)
eq_(list(qs), [q1])
qs = self.filter_instance.filter_solved_by(self.queryset, a3.creator.username)
eq_(list(qs), [q3])
@raises(APIException)
def test_metadata_not_json(self):
self.filter_instance.filter_metadata(self.queryset, 'not json')
@raises(APIException)
def test_metadata_bad_json(self):
self.filter_instance.filter_metadata(self.queryset, 'not json')
def test_single_filter_match(self):
q1 = question(metadata={'os': 'Linux'}, save=True)
question(metadata={'os': 'OSX'}, save=True)
res = self.filter({'os': 'Linux'})
eq_(list(res), [q1])
def test_single_filter_no_match(self):
question(metadata={'os': 'Linux'}, save=True)
question(metadata={'os': 'OSX'}, save=True)
res = self.filter({"os": "Windows 8"})
eq_(list(res), [])
def test_multi_filter_is_and(self):
q1 = question(metadata={'os': 'Linux', 'category': 'troubleshooting'}, save=True)
question(metadata={'os': 'OSX', 'category': 'troubleshooting'}, save=True)
res = self.filter({'os': 'Linux', 'category': 'troubleshooting'})
eq_(list(res), [q1])
def test_list_value_is_or(self):
q1 = question(metadata={'os': 'Linux'}, save=True)
q2 = question(metadata={'os': 'OSX'}, save=True)
question(metadata={'os': 'Windows 7'}, save=True)
res = self.filter({'os': ['Linux', 'OSX']})
eq_(sorted(res, key=lambda q: q.id), [q1, q2])
def test_none_value_is_missing(self):
q1 = question(metadata={}, save=True)
question(metadata={'os': 'Linux'}, save=True)
res = self.filter({'os': None})
eq_(list(res), [q1])
def test_list_value_with_none(self):
q1 = question(metadata={'os': 'Linux'}, save=True)
q2 = question(metadata={}, save=True)
question(metadata={'os': 'Windows 7'}, save=True)
res = self.filter({'os': ['Linux', None]})
eq_(sorted(res, key=lambda q: q.id), [q1, q2])
def test_is_taken(self):
u = user(save=True)
taken_until = datetime.now() + timedelta(seconds=30)
q = question(taken_by=u, taken_until=taken_until, save=True)
question(save=True)
res = self.filter_instance.filter_is_taken(self.queryset, True)
eq_(list(res), [q])
def test_is_not_taken(self):
u = user(save=True)
taken_until = datetime.now() + timedelta(seconds=30)
question(taken_by=u, taken_until=taken_until, save=True)
q = question(save=True)
res = self.filter_instance.filter_is_taken(self.queryset, False)
eq_(list(res), [q])
def test_is_taken_expired(self):
u = user(save=True)
taken_until = datetime.now() - timedelta(seconds=30)
question(taken_by=u, taken_until=taken_until, save=True)
res = self.filter_instance.filter_is_taken(self.queryset, True)
eq_(list(res), [])
def test_is_not_taken_expired(self):
u = user(save=True)
taken_until = datetime.now() - timedelta(seconds=30)
q = question(taken_by=u, taken_until=taken_until, save=True)
res = self.filter_instance.filter_is_taken(self.queryset, False)
eq_(list(res), [q])
def test_it_works_with_users_who_have_gotten_first_contrib_emails(self):
# This flag caused a regression, tracked in bug 1163855.
# The error was that the help text on the field was a str instead of a
# unicode. Yes, really, that matters apparently.
u = profile(first_answer_email_sent=True).user
question(creator=u, save=True)
url = reverse('question-list')
res = self.client.get(url)
eq_(res.status_code, 200)
| bsd-3-clause |
moraesnicol/scrapy | scrapy/cmdline.py | 84 | 5795 | from __future__ import print_function
import sys
import optparse
import cProfile
import inspect
import pkg_resources
import scrapy
from scrapy.crawler import CrawlerProcess
from scrapy.xlib import lsprofcalltree
from scrapy.commands import ScrapyCommand
from scrapy.exceptions import UsageError
from scrapy.utils.misc import walk_modules
from scrapy.utils.project import inside_project, get_project_settings
from scrapy.settings.deprecated import check_deprecated_settings
def _iter_command_classes(module_name):
# TODO: add `name` attribute to commands and and merge this function with
# scrapy.utils.spider.iter_spider_classes
for module in walk_modules(module_name):
for obj in vars(module).values():
if inspect.isclass(obj) and \
issubclass(obj, ScrapyCommand) and \
obj.__module__ == module.__name__:
yield obj
def _get_commands_from_module(module, inproject):
d = {}
for cmd in _iter_command_classes(module):
if inproject or not cmd.requires_project:
cmdname = cmd.__module__.split('.')[-1]
d[cmdname] = cmd()
return d
def _get_commands_from_entry_points(inproject, group='scrapy.commands'):
cmds = {}
for entry_point in pkg_resources.iter_entry_points(group):
obj = entry_point.load()
if inspect.isclass(obj):
cmds[entry_point.name] = obj()
else:
raise Exception("Invalid entry point %s" % entry_point.name)
return cmds
def _get_commands_dict(settings, inproject):
cmds = _get_commands_from_module('scrapy.commands', inproject)
cmds.update(_get_commands_from_entry_points(inproject))
cmds_module = settings['COMMANDS_MODULE']
if cmds_module:
cmds.update(_get_commands_from_module(cmds_module, inproject))
return cmds
def _pop_command_name(argv):
i = 0
for arg in argv[1:]:
if not arg.startswith('-'):
del argv[i]
return arg
i += 1
def _print_header(settings, inproject):
if inproject:
print("Scrapy %s - project: %s\n" % (scrapy.__version__, \
settings['BOT_NAME']))
else:
print("Scrapy %s - no active project\n" % scrapy.__version__)
def _print_commands(settings, inproject):
_print_header(settings, inproject)
print("Usage:")
print(" scrapy <command> [options] [args]\n")
print("Available commands:")
cmds = _get_commands_dict(settings, inproject)
for cmdname, cmdclass in sorted(cmds.items()):
print(" %-13s %s" % (cmdname, cmdclass.short_desc()))
if not inproject:
print()
print(" [ more ] More commands available when run from project directory")
print()
print('Use "scrapy <command> -h" to see more info about a command')
def _print_unknown_command(settings, cmdname, inproject):
_print_header(settings, inproject)
print("Unknown command: %s\n" % cmdname)
print('Use "scrapy" to see available commands')
def _run_print_help(parser, func, *a, **kw):
try:
func(*a, **kw)
except UsageError as e:
if str(e):
parser.error(str(e))
if e.print_help:
parser.print_help()
sys.exit(2)
def execute(argv=None, settings=None):
if argv is None:
argv = sys.argv
# --- backwards compatibility for scrapy.conf.settings singleton ---
if settings is None and 'scrapy.conf' in sys.modules:
from scrapy import conf
if hasattr(conf, 'settings'):
settings = conf.settings
# ------------------------------------------------------------------
if settings is None:
settings = get_project_settings()
check_deprecated_settings(settings)
# --- backwards compatibility for scrapy.conf.settings singleton ---
import warnings
from scrapy.exceptions import ScrapyDeprecationWarning
with warnings.catch_warnings():
warnings.simplefilter("ignore", ScrapyDeprecationWarning)
from scrapy import conf
conf.settings = settings
# ------------------------------------------------------------------
inproject = inside_project()
cmds = _get_commands_dict(settings, inproject)
cmdname = _pop_command_name(argv)
parser = optparse.OptionParser(formatter=optparse.TitledHelpFormatter(), \
conflict_handler='resolve')
if not cmdname:
_print_commands(settings, inproject)
sys.exit(0)
elif cmdname not in cmds:
_print_unknown_command(settings, cmdname, inproject)
sys.exit(2)
cmd = cmds[cmdname]
parser.usage = "scrapy %s %s" % (cmdname, cmd.syntax())
parser.description = cmd.long_desc()
settings.setdict(cmd.default_settings, priority='command')
cmd.settings = settings
cmd.add_options(parser)
opts, args = parser.parse_args(args=argv[1:])
_run_print_help(parser, cmd.process_options, args, opts)
cmd.crawler_process = CrawlerProcess(settings)
_run_print_help(parser, _run_command, cmd, args, opts)
sys.exit(cmd.exitcode)
def _run_command(cmd, args, opts):
if opts.profile or opts.lsprof:
_run_command_profiled(cmd, args, opts)
else:
cmd.run(args, opts)
def _run_command_profiled(cmd, args, opts):
if opts.profile:
sys.stderr.write("scrapy: writing cProfile stats to %r\n" % opts.profile)
if opts.lsprof:
sys.stderr.write("scrapy: writing lsprof stats to %r\n" % opts.lsprof)
loc = locals()
p = cProfile.Profile()
p.runctx('cmd.run(args, opts)', globals(), loc)
if opts.profile:
p.dump_stats(opts.profile)
k = lsprofcalltree.KCacheGrind(p)
if opts.lsprof:
with open(opts.lsprof, 'w') as f:
k.output(f)
if __name__ == '__main__':
execute()
| bsd-3-clause |
manuelm/pyload | module/lib/simplejson/__init__.py | 45 | 18626 | r"""JSON (JavaScript Object Notation) <http://json.org> is a subset of
JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
interchange format.
:mod:`simplejson` exposes an API familiar to users of the standard library
:mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
version of the :mod:`json` library contained in Python 2.6, but maintains
compatibility with Python 2.4 and Python 2.5 and (currently) has
significant performance advantages, even without using the optional C
extension for speedups.
Encoding basic Python object hierarchies::
>>> import simplejson as json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
>>> print json.dumps("\"foo\bar")
"\"foo\bar"
>>> print json.dumps(u'\u1234')
"\u1234"
>>> print json.dumps('\\')
"\\"
>>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
{"a": 0, "b": 0, "c": 0}
>>> from StringIO import StringIO
>>> io = StringIO()
>>> json.dump(['streaming API'], io)
>>> io.getvalue()
'["streaming API"]'
Compact encoding::
>>> import simplejson as json
>>> json.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))
'[1,2,3,{"4":5,"6":7}]'
Pretty printing::
>>> import simplejson as json
>>> s = json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=' ')
>>> print '\n'.join([l.rstrip() for l in s.splitlines()])
{
"4": 5,
"6": 7
}
Decoding JSON::
>>> import simplejson as json
>>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
True
>>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar'
True
>>> from StringIO import StringIO
>>> io = StringIO('["streaming API"]')
>>> json.load(io)[0] == 'streaming API'
True
Specializing JSON object decoding::
>>> import simplejson as json
>>> def as_complex(dct):
... if '__complex__' in dct:
... return complex(dct['real'], dct['imag'])
... return dct
...
>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
... object_hook=as_complex)
(1+2j)
>>> from decimal import Decimal
>>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
True
Specializing JSON object encoding::
>>> import simplejson as json
>>> def encode_complex(obj):
... if isinstance(obj, complex):
... return [obj.real, obj.imag]
... raise TypeError(repr(o) + " is not JSON serializable")
...
>>> json.dumps(2 + 1j, default=encode_complex)
'[2.0, 1.0]'
>>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
'[2.0, 1.0]'
>>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
'[2.0, 1.0]'
Using simplejson.tool from the shell to validate and pretty-print::
$ echo '{"json":"obj"}' | python -m simplejson.tool
{
"json": "obj"
}
$ echo '{ 1.2:3.4}' | python -m simplejson.tool
Expecting property name: line 1 column 2 (char 2)
"""
__version__ = '2.2.1'
__all__ = [
'dump', 'dumps', 'load', 'loads',
'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
'OrderedDict',
]
__author__ = 'Bob Ippolito <bob@redivi.com>'
from decimal import Decimal
from decoder import JSONDecoder, JSONDecodeError
from encoder import JSONEncoder
def _import_OrderedDict():
import collections
try:
return collections.OrderedDict
except AttributeError:
import ordered_dict
return ordered_dict.OrderedDict
OrderedDict = _import_OrderedDict()
def _import_c_make_encoder():
try:
from simplejson._speedups import make_encoder
return make_encoder
except ImportError:
return None
_default_encoder = JSONEncoder(
skipkeys=False,
ensure_ascii=True,
check_circular=True,
allow_nan=True,
indent=None,
separators=None,
encoding='utf-8',
default=None,
use_decimal=True,
namedtuple_as_object=True,
tuple_as_array=True,
)
def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
encoding='utf-8', default=None, use_decimal=True,
namedtuple_as_object=True, tuple_as_array=True,
**kw):
"""Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
``.write()``-supporting file-like object).
If ``skipkeys`` is true then ``dict`` keys that are not basic types
(``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
will be skipped instead of raising a ``TypeError``.
If ``ensure_ascii`` is false, then the some chunks written to ``fp``
may be ``unicode`` instances, subject to normal Python ``str`` to
``unicode`` coercion rules. Unless ``fp.write()`` explicitly
understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
to cause an error.
If ``check_circular`` is false, then the circular reference check
for container types will be skipped and a circular reference will
result in an ``OverflowError`` (or worse).
If ``allow_nan`` is false, then it will be a ``ValueError`` to
serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
in strict compliance of the JSON specification, instead of using the
JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
If *indent* is a string, then JSON array elements and object members
will be pretty-printed with a newline followed by that string repeated
for each level of nesting. ``None`` (the default) selects the most compact
representation without any newlines. For backwards compatibility with
versions of simplejson earlier than 2.1.0, an integer is also accepted
and is converted to a string with that many spaces.
If ``separators`` is an ``(item_separator, dict_separator)`` tuple
then it will be used instead of the default ``(', ', ': ')`` separators.
``(',', ':')`` is the most compact JSON representation.
``encoding`` is the character encoding for str instances, default is UTF-8.
``default(obj)`` is a function that should return a serializable version
of obj or raise TypeError. The default simply raises TypeError.
If *use_decimal* is true (default: ``True``) then decimal.Decimal
will be natively serialized to JSON with full precision.
If *namedtuple_as_object* is true (default: ``True``),
:class:`tuple` subclasses with ``_asdict()`` methods will be encoded
as JSON objects.
If *tuple_as_array* is true (default: ``True``),
:class:`tuple` (and subclasses) will be encoded as JSON arrays.
To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
``.default()`` method to serialize additional types), specify it with
the ``cls`` kwarg.
"""
# cached encoder
if (not skipkeys and ensure_ascii and
check_circular and allow_nan and
cls is None and indent is None and separators is None and
encoding == 'utf-8' and default is None and use_decimal
and namedtuple_as_object and tuple_as_array and not kw):
iterable = _default_encoder.iterencode(obj)
else:
if cls is None:
cls = JSONEncoder
iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
check_circular=check_circular, allow_nan=allow_nan, indent=indent,
separators=separators, encoding=encoding,
default=default, use_decimal=use_decimal,
namedtuple_as_object=namedtuple_as_object,
tuple_as_array=tuple_as_array,
**kw).iterencode(obj)
# could accelerate with writelines in some versions of Python, at
# a debuggability cost
for chunk in iterable:
fp.write(chunk)
def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
encoding='utf-8', default=None, use_decimal=True,
namedtuple_as_object=True,
tuple_as_array=True,
**kw):
"""Serialize ``obj`` to a JSON formatted ``str``.
If ``skipkeys`` is false then ``dict`` keys that are not basic types
(``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
will be skipped instead of raising a ``TypeError``.
If ``ensure_ascii`` is false, then the return value will be a
``unicode`` instance subject to normal Python ``str`` to ``unicode``
coercion rules instead of being escaped to an ASCII ``str``.
If ``check_circular`` is false, then the circular reference check
for container types will be skipped and a circular reference will
result in an ``OverflowError`` (or worse).
If ``allow_nan`` is false, then it will be a ``ValueError`` to
serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
strict compliance of the JSON specification, instead of using the
JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
If ``indent`` is a string, then JSON array elements and object members
will be pretty-printed with a newline followed by that string repeated
for each level of nesting. ``None`` (the default) selects the most compact
representation without any newlines. For backwards compatibility with
versions of simplejson earlier than 2.1.0, an integer is also accepted
and is converted to a string with that many spaces.
If ``separators`` is an ``(item_separator, dict_separator)`` tuple
then it will be used instead of the default ``(', ', ': ')`` separators.
``(',', ':')`` is the most compact JSON representation.
``encoding`` is the character encoding for str instances, default is UTF-8.
``default(obj)`` is a function that should return a serializable version
of obj or raise TypeError. The default simply raises TypeError.
If *use_decimal* is true (default: ``True``) then decimal.Decimal
will be natively serialized to JSON with full precision.
If *namedtuple_as_object* is true (default: ``True``),
:class:`tuple` subclasses with ``_asdict()`` methods will be encoded
as JSON objects.
If *tuple_as_array* is true (default: ``True``),
:class:`tuple` (and subclasses) will be encoded as JSON arrays.
To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
``.default()`` method to serialize additional types), specify it with
the ``cls`` kwarg.
"""
# cached encoder
if (not skipkeys and ensure_ascii and
check_circular and allow_nan and
cls is None and indent is None and separators is None and
encoding == 'utf-8' and default is None and use_decimal
and namedtuple_as_object and tuple_as_array and not kw):
return _default_encoder.encode(obj)
if cls is None:
cls = JSONEncoder
return cls(
skipkeys=skipkeys, ensure_ascii=ensure_ascii,
check_circular=check_circular, allow_nan=allow_nan, indent=indent,
separators=separators, encoding=encoding, default=default,
use_decimal=use_decimal,
namedtuple_as_object=namedtuple_as_object,
tuple_as_array=tuple_as_array,
**kw).encode(obj)
_default_decoder = JSONDecoder(encoding=None, object_hook=None,
object_pairs_hook=None)
def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
parse_int=None, parse_constant=None, object_pairs_hook=None,
use_decimal=False, namedtuple_as_object=True, tuple_as_array=True,
**kw):
"""Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
a JSON document) to a Python object.
*encoding* determines the encoding used to interpret any
:class:`str` objects decoded by this instance (``'utf-8'`` by
default). It has no effect when decoding :class:`unicode` objects.
Note that currently only encodings that are a superset of ASCII work,
strings of other encodings should be passed in as :class:`unicode`.
*object_hook*, if specified, will be called with the result of every
JSON object decoded and its return value will be used in place of the
given :class:`dict`. This can be used to provide custom
deserializations (e.g. to support JSON-RPC class hinting).
*object_pairs_hook* is an optional function that will be called with
the result of any object literal decode with an ordered list of pairs.
The return value of *object_pairs_hook* will be used instead of the
:class:`dict`. This feature can be used to implement custom decoders
that rely on the order that the key and value pairs are decoded (for
example, :func:`collections.OrderedDict` will remember the order of
insertion). If *object_hook* is also defined, the *object_pairs_hook*
takes priority.
*parse_float*, if specified, will be called with the string of every
JSON float to be decoded. By default, this is equivalent to
``float(num_str)``. This can be used to use another datatype or parser
for JSON floats (e.g. :class:`decimal.Decimal`).
*parse_int*, if specified, will be called with the string of every
JSON int to be decoded. By default, this is equivalent to
``int(num_str)``. This can be used to use another datatype or parser
for JSON integers (e.g. :class:`float`).
*parse_constant*, if specified, will be called with one of the
following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This
can be used to raise an exception if invalid JSON numbers are
encountered.
If *use_decimal* is true (default: ``False``) then it implies
parse_float=decimal.Decimal for parity with ``dump``.
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
kwarg.
"""
return loads(fp.read(),
encoding=encoding, cls=cls, object_hook=object_hook,
parse_float=parse_float, parse_int=parse_int,
parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,
use_decimal=use_decimal, **kw)
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
parse_int=None, parse_constant=None, object_pairs_hook=None,
use_decimal=False, **kw):
"""Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
document) to a Python object.
*encoding* determines the encoding used to interpret any
:class:`str` objects decoded by this instance (``'utf-8'`` by
default). It has no effect when decoding :class:`unicode` objects.
Note that currently only encodings that are a superset of ASCII work,
strings of other encodings should be passed in as :class:`unicode`.
*object_hook*, if specified, will be called with the result of every
JSON object decoded and its return value will be used in place of the
given :class:`dict`. This can be used to provide custom
deserializations (e.g. to support JSON-RPC class hinting).
*object_pairs_hook* is an optional function that will be called with
the result of any object literal decode with an ordered list of pairs.
The return value of *object_pairs_hook* will be used instead of the
:class:`dict`. This feature can be used to implement custom decoders
that rely on the order that the key and value pairs are decoded (for
example, :func:`collections.OrderedDict` will remember the order of
insertion). If *object_hook* is also defined, the *object_pairs_hook*
takes priority.
*parse_float*, if specified, will be called with the string of every
JSON float to be decoded. By default, this is equivalent to
``float(num_str)``. This can be used to use another datatype or parser
for JSON floats (e.g. :class:`decimal.Decimal`).
*parse_int*, if specified, will be called with the string of every
JSON int to be decoded. By default, this is equivalent to
``int(num_str)``. This can be used to use another datatype or parser
for JSON integers (e.g. :class:`float`).
*parse_constant*, if specified, will be called with one of the
following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``. This
can be used to raise an exception if invalid JSON numbers are
encountered.
If *use_decimal* is true (default: ``False``) then it implies
parse_float=decimal.Decimal for parity with ``dump``.
To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
kwarg.
"""
if (cls is None and encoding is None and object_hook is None and
parse_int is None and parse_float is None and
parse_constant is None and object_pairs_hook is None
and not use_decimal and not kw):
return _default_decoder.decode(s)
if cls is None:
cls = JSONDecoder
if object_hook is not None:
kw['object_hook'] = object_hook
if object_pairs_hook is not None:
kw['object_pairs_hook'] = object_pairs_hook
if parse_float is not None:
kw['parse_float'] = parse_float
if parse_int is not None:
kw['parse_int'] = parse_int
if parse_constant is not None:
kw['parse_constant'] = parse_constant
if use_decimal:
if parse_float is not None:
raise TypeError("use_decimal=True implies parse_float=Decimal")
kw['parse_float'] = Decimal
return cls(encoding=encoding, **kw).decode(s)
def _toggle_speedups(enabled):
import simplejson.decoder as dec
import simplejson.encoder as enc
import simplejson.scanner as scan
c_make_encoder = _import_c_make_encoder()
if enabled:
dec.scanstring = dec.c_scanstring or dec.py_scanstring
enc.c_make_encoder = c_make_encoder
enc.encode_basestring_ascii = (enc.c_encode_basestring_ascii or
enc.py_encode_basestring_ascii)
scan.make_scanner = scan.c_make_scanner or scan.py_make_scanner
else:
dec.scanstring = dec.py_scanstring
enc.c_make_encoder = None
enc.encode_basestring_ascii = enc.py_encode_basestring_ascii
scan.make_scanner = scan.py_make_scanner
dec.make_scanner = scan.make_scanner
global _default_decoder
_default_decoder = JSONDecoder(
encoding=None,
object_hook=None,
object_pairs_hook=None,
)
global _default_encoder
_default_encoder = JSONEncoder(
skipkeys=False,
ensure_ascii=True,
check_circular=True,
allow_nan=True,
indent=None,
separators=None,
encoding='utf-8',
default=None,
)
| gpl-3.0 |
mcanthony/nupic | examples/prediction/experiments/confidenceTest/base/permutations_secondOrder0.py | 43 | 1423 | #!/usr/bin/env python
permutations = dict(
dataSetPackage = ['secondOrder0'],
iterationCountTrain = [250, 500, 1000, 1500],
iterationCountTest = [250, 500],
spNumActivePerInhArea = [5],
tpNCellsPerCol = [5],
tpInitialPerm = [0.11, 0.21, 0.31, 0.41],
tpPermanenceInc = [0.05, 0.10],
tpGlobalDecay = [0.05, 0.10],
tpMaxAge = [50, 75, 100, 200, 300],
)
report = ['overallTime',
'postProc_confidenceTest_baseline:inputPredScore_burnIn1',
'postProc_confidenceTest_baseline:ngram:inputPredScore_n2_burnIn1',
]
optimize = 'postProc_confidenceTest_baseline:inputPredScore_burnIn1'
def filter(perm):
""" This function can be used to selectively filter out specific permutation
combinations. It is called for every possible permutation of the variables
in the permutations dict. It should return True for valid a combination of
permutation values and False for an invalid one.
Parameters:
---------------------------------------------------------
perm: dict of one possible combination of name:value
pairs chosen from permutations.
"""
if perm['tpPermanenceInc'] != perm['tpGlobalDecay']:
return False
return True
| agpl-3.0 |
prakritish/ansible | lib/ansible/plugins/lookup/lines.py | 89 | 1490 | # (c) 2012, Daniel Hokka Zakrisson <daniel@hozac.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
import subprocess
from ansible.errors import AnsibleError
from ansible.plugins.lookup import LookupBase
from ansible.module_utils._text import to_text
class LookupModule(LookupBase):
def run(self, terms, variables, **kwargs):
ret = []
for term in terms:
p = subprocess.Popen(term, cwd=self._loader.get_basedir(), shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
(stdout, stderr) = p.communicate()
if p.returncode == 0:
ret.extend([to_text(l) for l in stdout.splitlines()])
else:
raise AnsibleError("lookup_plugin.lines(%s) returned %d" % (term, p.returncode))
return ret
| gpl-3.0 |
Yadnyawalkya/integration_tests | cfme/scripting/quickstart/__init__.py | 2 | 6039 | import argparse
import hashlib
import json
import os
import subprocess
import sys
from cfme.scripting.quickstart.proc import PRISTINE_ENV
from cfme.scripting.quickstart.proc import run_cmd_or_exit
from cfme.scripting.quickstart.system import install_system_packages
CREATED = object()
REQUIREMENT_FILE = 'requirements/frozen.py3.txt'
if sys.version_info.major != 3 and sys.version_info.minor >= 7:
print("ERROR: quickstart only runs in python 3.7+")
sys.exit(2)
IN_VENV = os.path.exists(os.path.join(sys.prefix, 'pyvenv.cfg'))
IN_LEGACY_VIRTUALENV = getattr(sys, 'real_prefix', None) is not None
IN_VIRTUAL_ENV = IN_VENV or IN_LEGACY_VIRTUALENV
def mk_parser(default_venv_path):
parser = argparse.ArgumentParser()
parser.add_argument("--mk-virtualenv", default=default_venv_path)
parser.add_argument("--system-site-packages", action="store_true")
parser.add_argument("--config-path", default="../cfme-qe-yamls/complete/")
parser.add_argument("--debuginfo-install", action="store_true")
return parser
def args_for_current_venv():
parser = mk_parser(sys.prefix)
return parser.parse_args([])
def pip_json_list(venv):
os.environ.pop('PYTHONHOME', None)
proc = subprocess.Popen([
os.path.join(venv, 'bin/pip3'),
'list', '--format=json',
], stdout=subprocess.PIPE)
return json.load(proc.stdout)
def setup_virtualenv(target, use_site):
# check for bin in case "venv" is a precreated empty folder
if os.path.isdir(os.path.join(target, 'bin')):
print("INFO: Virtualenv", target, "already exists, skipping creation")
ret = CREATED # object that can be checked against to see if the venv exists
else:
add = ['--system-site-packages'] if use_site else []
run_cmd_or_exit([sys.executable, '-m', 'venv', target] + add)
ret = None
venv_call(target,
'pip3', 'install', '-U',
# pip wheel and setuptools are updated just in case
# since enterprise distros ship versions that are too stable
# for our purposes
'pip', 'wheel', 'setuptools',
# setuptools_scm and docutils installation prevents
# missbehaved packages from failing
'setuptools_scm', 'docutils', 'pbr')
return ret # used for venv state
def venv_call(venv_path, command, *args, **kwargs):
# pop PYTHONHOME to avoid nested environments
os.environ.pop('PYTHONHOME', None)
run_cmd_or_exit([
os.path.join(venv_path, 'bin', command),
] + list(args), **kwargs)
def hash_file(path):
content_hash = hashlib.sha1()
with open(path, 'rb') as fp:
content_hash.update(fp.read())
return content_hash.hexdigest()
def install_requirements(venv_path, quiet=False):
remember_file = os.path.join(venv_path, '.cfme_requirements_hash')
current_hash = hash_file(REQUIREMENT_FILE)
if os.path.isfile(remember_file):
with open(remember_file, 'r') as fp:
last_hash = fp.read()
elif os.path.exists(remember_file):
sys.exit("ERROR: {} is required to be a file".format(remember_file))
else:
last_hash = None
if last_hash == current_hash:
print("INFO: skipping requirement installation as frozen ones didn't change")
print(" to enforce please invoke pip manually")
return
elif last_hash is not None:
current_packages = pip_json_list(venv_path)
print("INFO:", REQUIREMENT_FILE, 'changed, updating virtualenv')
venv_call(
venv_path,
'pip3', 'install',
'-r', REQUIREMENT_FILE,
'--no-binary', 'pycurl',
*(['-q'] if quiet else []), long_running=quiet)
with open(remember_file, 'w') as fp:
fp.write(current_hash)
if last_hash is not None:
updated_packages = pip_json_list(venv_path)
print_packages_diff(old=current_packages, new=updated_packages)
def pip_version_list_to_map(version_list):
res = {}
for item in version_list:
try:
res[item['name']] = item['version']
except KeyError:
pass
return res
def print_packages_diff(old, new):
old_versions = pip_version_list_to_map(old)
new_versions = pip_version_list_to_map(new)
print_version_diff(old_versions, new_versions)
def version_changes(old, new):
names = sorted(set(old) | set(new))
for name in names:
initial = old.get(name, 'missing')
afterwards = new.get(name, 'removed')
if initial != afterwards:
yield name, initial, afterwards
def print_version_diff(old, new):
changes = list(version_changes(old, new))
if changes:
print("INFO: changed versions"),
for name, old, new in changes:
print(" ", name, old, '->', new)
def self_install(venv_path):
venv_call(venv_path, 'pip3', 'install', '-q', '-e', '.')
def disable_bytecode(venv_path):
venv_call(venv_path, 'python3', '-m', 'cfme.scripting.disable_bytecode')
def link_config_files(venv_path, src, dest):
venv_call(venv_path, 'python3', '-m', 'cfme.scripting.link_config', src, dest)
def ensure_pycurl_works(venv_path):
venv_call(venv_path, 'python3', '-c', 'import curl', env=PRISTINE_ENV)
def main(args):
if __package__ is None:
print("ERROR: quickstart must be invoked as module")
sys.exit(1)
install_system_packages(args.debuginfo_install)
venv_state = setup_virtualenv(args.mk_virtualenv, args.system_site_packages)
install_requirements(args.mk_virtualenv,
quiet=(venv_state is CREATED)) # quiet if the venv already existed
disable_bytecode(args.mk_virtualenv)
self_install(args.mk_virtualenv)
link_config_files(args.mk_virtualenv, args.config_path, 'conf')
ensure_pycurl_works(args.mk_virtualenv)
if not IN_VIRTUAL_ENV:
print("INFO: please remember to activate the virtualenv via")
print(" .", os.path.join(args.mk_virtualenv, 'bin/activate'))
| gpl-2.0 |
damiansoriano/odoo | addons/account/report/account_entries_report.py | 12 | 7679 | # -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from openerp import tools
from openerp.osv import fields,osv
import openerp.addons.decimal_precision as dp
class account_entries_report(osv.osv):
_name = "account.entries.report"
_description = "Journal Items Analysis"
_auto = False
_rec_name = 'date'
_columns = {
'date': fields.date('Effective Date', readonly=True),
'date_created': fields.date('Date Created', readonly=True),
'date_maturity': fields.date('Date Maturity', readonly=True),
'ref': fields.char('Reference', readonly=True),
'nbr': fields.integer('# of Items', readonly=True),
'debit': fields.float('Debit', readonly=True),
'credit': fields.float('Credit', readonly=True),
'balance': fields.float('Balance', readonly=True),
'currency_id': fields.many2one('res.currency', 'Currency', readonly=True),
'amount_currency': fields.float('Amount Currency', digits_compute=dp.get_precision('Account'), readonly=True),
'period_id': fields.many2one('account.period', 'Period', readonly=True),
'account_id': fields.many2one('account.account', 'Account', readonly=True),
'journal_id': fields.many2one('account.journal', 'Journal', readonly=True),
'fiscalyear_id': fields.many2one('account.fiscalyear', 'Fiscal Year', readonly=True),
'product_id': fields.many2one('product.product', 'Product', readonly=True),
'product_uom_id': fields.many2one('product.uom', 'Product Unit of Measure', readonly=True),
'move_state': fields.selection([('draft','Unposted'), ('posted','Posted')], 'Status', readonly=True),
'move_line_state': fields.selection([('draft','Unbalanced'), ('valid','Valid')], 'State of Move Line', readonly=True),
'reconcile_id': fields.many2one('account.move.reconcile', 'Reconciliation number', readonly=True),
'partner_id': fields.many2one('res.partner','Partner', readonly=True),
'analytic_account_id': fields.many2one('account.analytic.account', 'Analytic Account', readonly=True),
'quantity': fields.float('Products Quantity', digits=(16,2), readonly=True),
'user_type': fields.many2one('account.account.type', 'Account Type', readonly=True),
'type': fields.selection([
('receivable', 'Receivable'),
('payable', 'Payable'),
('cash', 'Cash'),
('view', 'View'),
('consolidation', 'Consolidation'),
('other', 'Regular'),
('closed', 'Closed'),
], 'Internal Type', readonly=True, help="This type is used to differentiate types with "\
"special effects in Odoo: view can not have entries, consolidation are accounts that "\
"can have children accounts for multi-company consolidations, payable/receivable are for "\
"partners accounts (for debit/credit computations), closed for depreciated accounts."),
'company_id': fields.many2one('res.company', 'Company', readonly=True),
}
_order = 'date desc'
def search(self, cr, uid, args, offset=0, limit=None, order=None,
context=None, count=False):
fiscalyear_obj = self.pool.get('account.fiscalyear')
period_obj = self.pool.get('account.period')
for arg in args:
if arg[0] == 'period_id' and arg[2] == 'current_period':
current_period = period_obj.find(cr, uid, context=context)[0]
args.append(['period_id','in',[current_period]])
break
elif arg[0] == 'period_id' and arg[2] == 'current_year':
current_year = fiscalyear_obj.find(cr, uid)
ids = fiscalyear_obj.read(cr, uid, [current_year], ['period_ids'])[0]['period_ids']
args.append(['period_id','in',ids])
for a in [['period_id','in','current_year'], ['period_id','in','current_period']]:
if a in args:
args.remove(a)
return super(account_entries_report, self).search(cr, uid, args=args, offset=offset, limit=limit, order=order,
context=context, count=count)
def read_group(self, cr, uid, domain, fields, groupby, offset=0, limit=None, context=None, orderby=False,lazy=True):
if context is None:
context = {}
fiscalyear_obj = self.pool.get('account.fiscalyear')
period_obj = self.pool.get('account.period')
if context.get('period', False) == 'current_period':
current_period = period_obj.find(cr, uid, context=context)[0]
domain.append(['period_id','in',[current_period]])
elif context.get('year', False) == 'current_year':
current_year = fiscalyear_obj.find(cr, uid)
ids = fiscalyear_obj.read(cr, uid, [current_year], ['period_ids'])[0]['period_ids']
domain.append(['period_id','in',ids])
else:
domain = domain
return super(account_entries_report, self).read_group(cr, uid, domain, fields, groupby, offset, limit, context, orderby,lazy)
def init(self, cr):
tools.drop_view_if_exists(cr, 'account_entries_report')
cr.execute("""
create or replace view account_entries_report as (
select
l.id as id,
am.date as date,
l.date_maturity as date_maturity,
l.date_created as date_created,
am.ref as ref,
am.state as move_state,
l.state as move_line_state,
l.reconcile_id as reconcile_id,
l.partner_id as partner_id,
l.product_id as product_id,
l.product_uom_id as product_uom_id,
am.company_id as company_id,
am.journal_id as journal_id,
p.fiscalyear_id as fiscalyear_id,
am.period_id as period_id,
l.account_id as account_id,
l.analytic_account_id as analytic_account_id,
a.type as type,
a.user_type as user_type,
1 as nbr,
l.quantity as quantity,
l.currency_id as currency_id,
l.amount_currency as amount_currency,
l.debit as debit,
l.credit as credit,
l.debit-l.credit as balance
from
account_move_line l
left join account_account a on (l.account_id = a.id)
left join account_move am on (am.id=l.move_id)
left join account_period p on (am.period_id=p.id)
where l.state != 'draft'
)
""")
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
| agpl-3.0 |
dbushong/dotfiles | dot.vim/plugin/editorconfig-core-py/docs/conf.py | 19 | 7189 | # -*- coding: utf-8 -*-
#
# EditorConfig Python Core documentation build configuration file, created by
# sphinx-quickstart on Sat May 5 09:51:42 2012.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
import editorconfig
from editorconfig import __version__
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'EditorConfig Python Core'
copyright = u'2012, EditorConfig Team'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = __version__
# The full version, including alpha/beta/rc tags.
release = __version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'agogo'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'EditorConfigPythonCoredoc'
# -- Options for LaTeX output --------------------------------------------------
# The paper size ('letter' or 'a4').
#latex_paper_size = 'letter'
# The font size ('10pt', '11pt' or '12pt').
#latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'EditorConfigPythonCore.tex', u'EditorConfig Python Core Documentation',
u'EditorConfig Team', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Additional stuff for the LaTeX preamble.
#latex_preamble = ''
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'editorconfigpythoncore', u'EditorConfig Python Core Documentation',
[u'EditorConfig Team'], 1)
]
| mit |
marrybird/flask-sqlalchemy | test_sqlalchemy.py | 7 | 23928 | from __future__ import with_statement
import atexit
import unittest
from datetime import datetime
import flask
import flask_sqlalchemy as sqlalchemy
from sqlalchemy import MetaData
from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy.orm import sessionmaker
def make_todo_model(db):
class Todo(db.Model):
__tablename__ = 'todos'
id = db.Column('todo_id', db.Integer, primary_key=True)
title = db.Column(db.String(60))
text = db.Column(db.String)
done = db.Column(db.Boolean)
pub_date = db.Column(db.DateTime)
def __init__(self, title, text):
self.title = title
self.text = text
self.done = False
self.pub_date = datetime.utcnow()
return Todo
class BasicAppTestCase(unittest.TestCase):
def setUp(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
self.Todo = make_todo_model(db)
@app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.query.all())
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(form['title'], form['text'])
db.session.add(todo)
db.session.commit()
return 'added'
db.create_all()
self.app = app
self.db = db
def tearDown(self):
self.db.drop_all()
def test_basic_insert(self):
c = self.app.test_client()
c.post('/add', data=dict(title='First Item', text='The text'))
c.post('/add', data=dict(title='2nd Item', text='The text'))
rv = c.get('/')
self.assertEqual(rv.data, b'First Item\n2nd Item')
def test_query_recording(self):
with self.app.test_request_context():
todo = self.Todo('Test 1', 'test')
self.db.session.add(todo)
self.db.session.commit()
queries = sqlalchemy.get_debug_queries()
self.assertEqual(len(queries), 1)
query = queries[0]
self.assertTrue('insert into' in query.statement.lower())
self.assertEqual(query.parameters[0], 'Test 1')
self.assertEqual(query.parameters[1], 'test')
self.assertTrue('test_sqlalchemy.py' in query.context)
self.assertTrue('test_query_recording' in query.context)
def test_helper_api(self):
self.assertEqual(self.db.metadata, self.db.Model.metadata)
class CustomMetaDataTestCase(unittest.TestCase):
def setUp(self):
self.app = flask.Flask(__name__)
self.app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
self.app.config['TESTING'] = True
def test_custom_metadata_positive(self):
convention = {
"ix": 'ix_%(column_0_label)s',
"uq": "uq_%(table_name)s_%(column_0_name)s",
"ck": "ck_%(table_name)s_%(constraint_name)s",
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
"pk": "pk_%(table_name)s"
}
metadata = MetaData(naming_convention=convention)
db = sqlalchemy.SQLAlchemy(self.app, metadata=metadata)
self.db = db
class One(db.Model):
id = db.Column(db.Integer, primary_key=True)
myindex = db.Column(db.Integer, index=True)
class Two(db.Model):
id = db.Column(db.Integer, primary_key=True)
one_id = db.Column(db.Integer, db.ForeignKey(One.id))
myunique = db.Column(db.Integer, unique=True)
self.assertEqual(list(One.__table__.constraints)[0].name, 'pk_one')
self.assertEqual(list(One.__table__.indexes)[0].name, 'ix_one_myindex')
self.assertTrue('fk_two_one_id_one' in [c.name for c in Two.__table__.constraints])
self.assertTrue('uq_two_myunique' in [c.name for c in Two.__table__.constraints])
self.assertTrue('pk_two' in [c.name for c in Two.__table__.constraints])
def test_custom_metadata_negative(self):
db = sqlalchemy.SQLAlchemy(self.app, metadata=None)
self.db = db
class One(db.Model):
id = db.Column(db.Integer, primary_key=True)
myindex = db.Column(db.Integer, index=True)
class Two(db.Model):
id = db.Column(db.Integer, primary_key=True)
one_id = db.Column(db.Integer, db.ForeignKey(One.id))
myunique = db.Column(db.Integer, unique=True)
self.assertNotEqual(list(One.__table__.constraints)[0].name, 'pk_one')
self.assertFalse('fk_two_one_id_one' in [c.name for c in Two.__table__.constraints])
self.assertFalse('uq_two_myunique' in [c.name for c in Two.__table__.constraints])
self.assertFalse('pk_two' in [c.name for c in Two.__table__.constraints])
class TestQueryProperty(unittest.TestCase):
def setUp(self):
self.app = flask.Flask(__name__)
self.app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
self.app.config['TESTING'] = True
def test_no_app_bound(self):
db = sqlalchemy.SQLAlchemy()
db.init_app(self.app)
Todo = make_todo_model(db)
# If no app is bound to the SQLAlchemy instance, a
# request context is required to access Model.query.
self.assertRaises(RuntimeError, getattr, Todo, 'query')
with self.app.test_request_context():
db.create_all()
todo = Todo('Test', 'test')
db.session.add(todo)
db.session.commit()
self.assertEqual(len(Todo.query.all()), 1)
def test_app_bound(self):
db = sqlalchemy.SQLAlchemy(self.app)
Todo = make_todo_model(db)
db.create_all()
# If an app was passed to the SQLAlchemy constructor,
# the query property is always available.
todo = Todo('Test', 'test')
db.session.add(todo)
db.session.commit()
self.assertEqual(len(Todo.query.all()), 1)
class SignallingTestCase(unittest.TestCase):
def setUp(self):
self.app = app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
self.db = sqlalchemy.SQLAlchemy(app)
self.Todo = make_todo_model(self.db)
self.db.create_all()
def tearDown(self):
self.db.drop_all()
def test_before_committed(self):
class Namespace(object):
is_received = False
def before_committed(sender, changes):
Namespace.is_received = True
with sqlalchemy.before_models_committed.connected_to(before_committed, sender=self.app):
todo = self.Todo('Awesome', 'the text')
self.db.session.add(todo)
self.db.session.commit()
self.assertTrue(Namespace.is_received)
def test_model_signals(self):
recorded = []
def committed(sender, changes):
self.assertTrue(isinstance(changes, list))
recorded.extend(changes)
with sqlalchemy.models_committed.connected_to(committed,
sender=self.app):
todo = self.Todo('Awesome', 'the text')
self.db.session.add(todo)
self.assertEqual(len(recorded), 0)
self.db.session.commit()
self.assertEqual(len(recorded), 1)
self.assertEqual(recorded[0][0], todo)
self.assertEqual(recorded[0][1], 'insert')
del recorded[:]
todo.text = 'aha'
self.db.session.commit()
self.assertEqual(len(recorded), 1)
self.assertEqual(recorded[0][0], todo)
self.assertEqual(recorded[0][1], 'update')
del recorded[:]
self.db.session.delete(todo)
self.db.session.commit()
self.assertEqual(len(recorded), 1)
self.assertEqual(recorded[0][0], todo)
self.assertEqual(recorded[0][1], 'delete')
class TablenameTestCase(unittest.TestCase):
def test_name(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
class BazBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Ham(db.Model):
__tablename__ = 'spam'
id = db.Column(db.Integer, primary_key=True)
self.assertEqual(FOOBar.__tablename__, 'foo_bar')
self.assertEqual(BazBar.__tablename__, 'baz_bar')
self.assertEqual(Ham.__tablename__, 'spam')
def test_single_name(self):
"""Single table inheritance should not set a new name."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Duck(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Mallard(Duck):
pass
self.assertEqual(Mallard.__tablename__, 'duck')
def test_joined_name(self):
"""Model has a separate primary key; it should set a new name."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Duck(db.Model):
id = db.Column(db.Integer, primary_key=True)
class Donald(Duck):
id = db.Column(db.Integer, db.ForeignKey(Duck.id), primary_key=True)
self.assertEqual(Donald.__tablename__, 'donald')
def test_mixin_name(self):
"""Primary key provided by mixin should still allow model to set tablename."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Base(object):
id = db.Column(db.Integer, primary_key=True)
class Duck(Base, db.Model):
pass
self.assertFalse(hasattr(Base, '__tablename__'))
self.assertEqual(Duck.__tablename__, 'duck')
def test_abstract_name(self):
"""Abstract model should not set a name. Subclass should set a name."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
class Duck(Base):
pass
self.assertFalse(hasattr(Base, '__tablename__'))
self.assertEqual(Duck.__tablename__, 'duck')
def test_complex_inheritance(self):
"""Joined table inheritance, but the new primary key is provided by a mixin, not directly on the class."""
app = flask.Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
db = sqlalchemy.SQLAlchemy(app)
class Duck(db.Model):
id = db.Column(db.Integer, primary_key=True)
class IdMixin(object):
@declared_attr
def id(cls):
return db.Column(db.Integer, db.ForeignKey(Duck.id), primary_key=True)
class RubberDuck(IdMixin, Duck):
pass
self.assertEqual(RubberDuck.__tablename__, 'rubber_duck')
class PaginationTestCase(unittest.TestCase):
def test_basic_pagination(self):
p = sqlalchemy.Pagination(None, 1, 20, 500, [])
self.assertEqual(p.page, 1)
self.assertFalse(p.has_prev)
self.assertTrue(p.has_next)
self.assertEqual(p.total, 500)
self.assertEqual(p.pages, 25)
self.assertEqual(p.next_num, 2)
self.assertEqual(list(p.iter_pages()),
[1, 2, 3, 4, 5, None, 24, 25])
p.page = 10
self.assertEqual(list(p.iter_pages()),
[1, 2, None, 8, 9, 10, 11, 12, 13, 14, None, 24, 25])
def test_pagination_pages_when_0_items_per_page(self):
p = sqlalchemy.Pagination(None, 1, 0, 500, [])
self.assertEqual(p.pages, 0)
def test_query_paginate(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
Todo = make_todo_model(db)
db.create_all()
with app.app_context():
db.session.add_all([Todo('', '') for _ in range(100)])
db.session.commit()
@app.route('/')
def index():
p = Todo.query.paginate()
return '{0} items retrieved'.format(len(p.items))
c = app.test_client()
# request default
r = c.get('/')
self.assertEqual(r.status_code, 200)
# request args
r = c.get('/?per_page=10')
self.assertEqual(r.data.decode('utf8'), '10 items retrieved')
with app.app_context():
# query default
p = Todo.query.paginate()
self.assertEqual(p.total, 100)
class BindsTestCase(unittest.TestCase):
def test_basic_binds(self):
import tempfile
_, db1 = tempfile.mkstemp()
_, db2 = tempfile.mkstemp()
def _remove_files():
import os
try:
os.remove(db1)
os.remove(db2)
except IOError:
pass
atexit.register(_remove_files)
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['SQLALCHEMY_BINDS'] = {
'foo': 'sqlite:///' + db1,
'bar': 'sqlite:///' + db2
}
db = sqlalchemy.SQLAlchemy(app)
class Foo(db.Model):
__bind_key__ = 'foo'
__table_args__ = {"info": {"bind_key": "foo"}}
id = db.Column(db.Integer, primary_key=True)
class Bar(db.Model):
__bind_key__ = 'bar'
id = db.Column(db.Integer, primary_key=True)
class Baz(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
# simple way to check if the engines are looked up properly
self.assertEqual(db.get_engine(app, None), db.engine)
for key in 'foo', 'bar':
engine = db.get_engine(app, key)
connector = app.extensions['sqlalchemy'].connectors[key]
self.assertEqual(engine, connector.get_engine())
self.assertEqual(str(engine.url),
app.config['SQLALCHEMY_BINDS'][key])
# do the models have the correct engines?
self.assertEqual(db.metadata.tables['foo'].info['bind_key'], 'foo')
self.assertEqual(db.metadata.tables['bar'].info['bind_key'], 'bar')
self.assertEqual(db.metadata.tables['baz'].info.get('bind_key'), None)
# see the tables created in an engine
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app, 'foo'))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('foo' in metadata.tables)
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app, 'bar'))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('bar' in metadata.tables)
metadata = db.MetaData()
metadata.reflect(bind=db.get_engine(app))
self.assertEqual(len(metadata.tables), 1)
self.assertTrue('baz' in metadata.tables)
# do the session have the right binds set?
self.assertEqual(db.get_binds(app), {
Foo.__table__: db.get_engine(app, 'foo'),
Bar.__table__: db.get_engine(app, 'bar'),
Baz.__table__: db.get_engine(app, None)
})
class DefaultQueryClassTestCase(unittest.TestCase):
def test_default_query_class(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
class Parent(db.Model):
id = db.Column(db.Integer, primary_key=True)
children = db.relationship("Child", backref = "parents", lazy='dynamic')
class Child(db.Model):
id = db.Column(db.Integer, primary_key=True)
parent_id = db.Column(db.Integer, db.ForeignKey('parent.id'))
p = Parent()
c = Child()
c.parent = p
self.assertEqual(type(Parent.query), sqlalchemy.BaseQuery)
self.assertEqual(type(Child.query), sqlalchemy.BaseQuery)
self.assertTrue(isinstance(p.children, sqlalchemy.BaseQuery))
#self.assertTrue(isinstance(c.parents, sqlalchemy.BaseQuery))
class SQLAlchemyIncludesTestCase(unittest.TestCase):
def test(self):
"""Various SQLAlchemy objects are exposed as attributes.
"""
db = sqlalchemy.SQLAlchemy()
import sqlalchemy as sqlalchemy_lib
self.assertTrue(db.Column == sqlalchemy_lib.Column)
# The Query object we expose is actually our own subclass.
from flask_sqlalchemy import BaseQuery
self.assertTrue(db.Query == BaseQuery)
class RegressionTestCase(unittest.TestCase):
def test_joined_inheritance(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
class Base(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.Unicode(20))
__mapper_args__ = {'polymorphic_on': type}
class SubBase(Base):
id = db.Column(db.Integer, db.ForeignKey('base.id'),
primary_key=True)
__mapper_args__ = {'polymorphic_identity': 'sub'}
self.assertEqual(Base.__tablename__, 'base')
self.assertEqual(SubBase.__tablename__, 'sub_base')
db.create_all()
def test_single_table_inheritance(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
class Base(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.Unicode(20))
__mapper_args__ = {'polymorphic_on': type}
class SubBase(Base):
__mapper_args__ = {'polymorphic_identity': 'sub'}
self.assertEqual(Base.__tablename__, 'base')
self.assertEqual(SubBase.__tablename__, 'base')
db.create_all()
def test_joined_inheritance_relation(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
class Relation(db.Model):
id = db.Column(db.Integer, primary_key=True)
base_id = db.Column(db.Integer, db.ForeignKey('base.id'))
name = db.Column(db.Unicode(20))
def __init__(self, name):
self.name = name
class Base(db.Model):
id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.Unicode(20))
__mapper_args__ = {'polymorphic_on': type}
class SubBase(Base):
id = db.Column(db.Integer, db.ForeignKey('base.id'),
primary_key=True)
__mapper_args__ = {'polymorphic_identity': u'sub'}
relations = db.relationship(Relation)
db.create_all()
base = SubBase()
base.relations = [Relation(name=u'foo')]
db.session.add(base)
db.session.commit()
base = base.query.one()
def test_connection_binds(self):
app = flask.Flask(__name__)
db = sqlalchemy.SQLAlchemy(app)
assert db.session.connection()
class SessionScopingTestCase(unittest.TestCase):
def test_default_session_scoping(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
with app.test_request_context():
fb = FOOBar()
db.session.add(fb)
assert fb in db.session
def test_session_scoping_changing(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
def scopefunc():
return id(dict())
db = sqlalchemy.SQLAlchemy(app, session_options=dict(scopefunc=scopefunc))
class FOOBar(db.Model):
id = db.Column(db.Integer, primary_key=True)
db.create_all()
with app.test_request_context():
fb = FOOBar()
db.session.add(fb)
assert fb not in db.session # because a new scope is generated on each call
class CommitOnTeardownTestCase(unittest.TestCase):
def setUp(self):
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
db = sqlalchemy.SQLAlchemy(app)
Todo = make_todo_model(db)
db.create_all()
@app.route('/')
def index():
return '\n'.join(x.title for x in Todo.query.all())
@app.route('/create', methods=['POST'])
def create():
db.session.add(Todo('Test one', 'test'))
if flask.request.form.get('fail'):
raise RuntimeError("Failing as requested")
return 'ok'
self.client = app.test_client()
def test_commit_on_success(self):
resp = self.client.post('/create')
self.assertEqual(resp.status_code, 200)
self.assertEqual(self.client.get('/').data, b'Test one')
def test_roll_back_on_failure(self):
resp = self.client.post('/create', data={'fail': 'on'})
self.assertEqual(resp.status_code, 500)
self.assertEqual(self.client.get('/').data, b'')
class StandardSessionTestCase(unittest.TestCase):
def test_insert_update_delete(self):
# Ensure _SignalTrackingMapperExtension doesn't croak when
# faced with a vanilla SQLAlchemy session.
#
# Verifies that "AttributeError: 'SessionMaker' object has no attribute '_model_changes'"
# is not thrown.
app = flask.Flask(__name__)
app.config['SQLALCHEMY_ENGINE'] = 'sqlite://'
app.config['TESTING'] = True
db = sqlalchemy.SQLAlchemy(app)
Session = sessionmaker(bind=db.engine)
class QazWsx(db.Model):
id = db.Column(db.Integer, primary_key=True)
x = db.Column(db.String, default='')
db.create_all()
session = Session()
session.add(QazWsx())
session.flush() # issues an INSERT.
session.expunge_all()
qaz_wsx = session.query(QazWsx).first()
assert qaz_wsx.x == ''
qaz_wsx.x = 'test'
session.flush() # issues an UPDATE.
session.expunge_all()
qaz_wsx = session.query(QazWsx).first()
assert qaz_wsx.x == 'test'
session.delete(qaz_wsx) # issues a DELETE.
assert session.query(QazWsx).first() is None
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(BasicAppTestCase))
suite.addTest(unittest.makeSuite(CustomMetaDataTestCase))
suite.addTest(unittest.makeSuite(TestQueryProperty))
suite.addTest(unittest.makeSuite(TablenameTestCase))
suite.addTest(unittest.makeSuite(PaginationTestCase))
suite.addTest(unittest.makeSuite(BindsTestCase))
suite.addTest(unittest.makeSuite(DefaultQueryClassTestCase))
suite.addTest(unittest.makeSuite(SQLAlchemyIncludesTestCase))
suite.addTest(unittest.makeSuite(RegressionTestCase))
suite.addTest(unittest.makeSuite(SessionScopingTestCase))
suite.addTest(unittest.makeSuite(CommitOnTeardownTestCase))
if flask.signals_available:
suite.addTest(unittest.makeSuite(SignallingTestCase))
suite.addTest(unittest.makeSuite(StandardSessionTestCase))
return suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')
| bsd-3-clause |
mysociety/pombola | pombola/kenya/shujaaz.py | 1 | 14407 | # -*- coding: utf-8 -*-
FINALISTS2014 = [
{
'category': 'Education (National Assembly)',
'name': 'Hon. Boniface Gatobu',
'person': 1322,
'reasons': '''<ul><li>Motion urging the Government, to
establish a public databank of all bright and poor students to be in the
custody of the County Director of Education, and such information
be disseminated and made available to the public institutions
including the respective Constituencies Development Fund
Committees which shall take into consideration when disbursing
bursaries and such other institutions that may be willing to
support such students. Proposed on 15th May, 2013 and adopted in
July 2013</li></ul>''',
},
{
'category': 'Education (Senate)',
'name': 'Sen. Boni Khalwale',
'person': 170,
'reasons': '''<ul><li>Motion on equitable distribution of
universities across counties. Notice mooted on 30th April 2013 and adopted
later in May, 2013</li></ul>''',
},
{
'category': 'Water',
'name': 'Hon. Amina Abdalla',
'person': 382,
'reasons': '''<ul><li>Contributions to the Water Bill 2014 on
the importance of the separation of responsibilities between the
water authorities at the national and county government levels.
(<a href="http://info.mzalendo.com/hansard/sitting/national_assembly/2014-10-23-14-30-00#entry-494909">Read
the debate on the moving of the Water Bill</a>.)</li></ul>''',
},
{
'category': 'Food',
'name': 'Sen. Beatrice Elachi',
'person': 13115,
'reasons': '<ul><li>The Food Security Bill.</li></ul>',
},
{
'category': 'Health (Senate)',
'name': 'Sen. Dr. Wilfred Machage',
'person': 179,
'reasons': '''<ul><li>Motion urging government to establish
level 5 hospitals in all 47 counties. Motion proposed on May 23rd and adopted
in June, 2013.</li></ul>''',
},
{
'category': 'Health (National Assembly)',
'name': 'Hon. James Nyikal',
'person': 434,
'reasons': '''<ul><li>Contributions on the health sector and
devolution: “Hon. Speaker, thank you. It is true that we have a big problem
of health in the country now, which has been made worse by the
process of devolution. What I have said here many times is that
we failed to devolve the way we planned in the Constitution. The
TA and the appropriate law have never been applied. One day the
governors, the Council of Governors and the President decided to
devolve healthcare in a day. It is not possible. The problem we
are seeing in healthcare is also in other places, only that in
health area players are noisy.”
(<a href="http://info.mzalendo.com/hansard/sitting/national_assembly/2014-08-20-14-30-00#entry-486463">See
the full speech and debate.</a>)</li></ul>''',
},
{
'category': 'Youth',
'name': 'Hon. Chris Wamalwa',
'person': 1889,
'reasons': '''<ul><li>The mode of disbursement of Kshs. 6
billion initially earmarked for a Presidential runoff, to be disbursed
to the youths and women groups across the Country. Sought on 17th, July
2013, Nairobi.</li></ul>''',
},
{
'category': 'Budgetary oversight',
'name': 'Hon. John Mbadi',
'person': 110,
'reasons': '''<ul><li>The salaries, allowances, and vehicles
allocated to constitutional commissioners. Sought on 4th June,
2013.</li></ul>''',
},
{
'category': 'Oversight (progressive legislation)',
'name': 'Hon. Kabando wa Kabando',
'person': 31,
'reasons': '''<ul><li>Proposed the reintroduction of Capital
gains tax that was included in the Finance Bill 2014</li><li>Central Bank
(amendment) Act, 2014</li><li>Followed up on the Status of the Kroll report
and capital gains flight</li></ul>''',
},
{
'category': 'Devolution',
'name': 'Sen. Kithure Kindiki',
'person': 1046,
'reasons': '''<ul><li>The County Allocation of Revenue Bill,
2013; The Community Land Bill; Division of Revenue Bill, 2014 (Sen. Bill No.12)
2013; County Allocation of Revenue Bill, 2014 (Sen. Bill No.13); Public Finance
Management (Amendment) Bill, 2014 (Sen. Bill No. 11); County Assembly Powers
and Privileges Bill, 2014 (Sen. Bill No. 14); Parliamentary Powers and
Privileges Bill, 2014 (Sen. Bill No. 15); The County Retirement Scheme
Bill;</li><li>Motion urging the national government to enter into
agreements with county government to transfer resources,
functions and powers to county governments.</li></ul>''',
},
]
FINALISTS2015 = [
{
'category': 'Financial Oversight',
'name': 'Col. (Rtd) Ali Rasso Dido',
'person': 2749,
'reasons': '''<h4>The Excise Duty Bill:</h4><blockquote><p>“Reading it tells me that our tax regime must be people friendly particularly in accessing goods which our people use daily. The citizenry have been taking goods to Uganda or Tanzania and bringing them back to Kenya. In the process, that fights competition and the traders who import their good directly to Kenya get disadvantaged.” <a href="http://info.mzalendo.com/hansard/sitting/national_assembly/2015-08-20-14-30-00#entry-577824">(Read more)</a></p></blockquote>'''
},
{
'category': 'Institutional Oversight',
'name': 'Prof. Anyang’ Nyong’o',
'person': 193,
'reasons': '''<h4>Motion on the state of Kenya Airways</h4><p>He proposed the Senate to establish a Select Committee to conduct an inquiry into the affairs of the Kenya Airways Limited and its subsidiaries and report to the Senate within three months, taking into account the following:</p><ol><li>The leasing and buying arrangement of aircrafts since 1996;</li><li>The role of off-shore companies in the investment affairs of the airline;</li><li>The identity of the shareholders of these off-shore companies and their relationship with the management of Kenya Airways Limited;</li><li>The employment policies and practices of personnel, including engineers, pilots, cabin crew and ground personnel;</li><li>The reason for delayed and cancelled flights, their frequency and the magnitude of losses attendant therein;</li><li>Any other matter that may shed light on the financial and management crisis currently facing the airline.</li></ol>'''
},
{
'category': 'Mining (Senate)',
'name': 'Francis Nyenze',
'person': 1987,
'reasons': '''<h4>The Petroleum Bill 2015</h4><blockquote><p>“There are a few places where I feel the committee fell short of. For instance, it has given the Cabinet Secretary (CS) too much power to negotiate contracts for petroleum. That is very wrong. It is good for the Committee to look at the possibility of having a board. A board is wider and it can consult more. Clause 46 obligates the contractor to conserve the environment and promote local industries by buying from them and adopt best practices.” <a href="http://info.mzalendo.com/hansard/sitting/national_assembly/2015-10-27-14-30-00#entry-595306">(Read more)</a></p></blockquote>'''
},
{
'category': 'Access to Justice',
'name': 'Amos Wako',
'person': 366,
'reasons': '''<h4>(Represents a committee)</h4><h4>The Committee Report on the annual Report (2012/2013) of the commission on Administrative Justice:</h4><blockquote><ol><li>The Commission on Administrative Justice prepares and presents to the Senate, a report on their proposed amendments to the Commission on Administrative Justice Act and any other statutory amendments, which they may consider necessary for the effective execution of their mandate.</li><li>The Commission on Administrative Justice to leverage on technology to increase accessibility and efficiency in complaints handling through use of toll free numbers; social media and other platforms such as the Integrated Public Complaints Referral Mechanism, the Huduma initiative and improvement of the ICT infrastructure at the Commission.</li><li>The CAJ to open branches in each of the 47 counties through partnerships with the county governments.</li></ol></blockquote>'''
},
{
'category': 'Devolution',
'name': 'Mutahi Kagwe',
'person': 229,
'reasons': '''<h4>The County Allocation of Revenue Allocation Bill</h4><blockquote><p>“Whichever way you look at it, we mediated successfully. This is because the money that we were looking for the counties went to them. It is good for us to repeat this because this is a House of record. Even if it meant that we give up our salaries to travel around the counties, forget about the oversight money, so that devolution works, I personally would be quite happy and willing to do so. If that is the sacrifice that has got to be made so that Kenya’s children can live better tomorrow, so be it.” <a href="http://info.mzalendo.com/hansard/sitting/senate/2015-06-17-14-30-00#entry-559027">(Read more)</a></p></blockquote>'''
},
{
'category': 'Education',
'name': 'Agnes Zani',
'person': 13119,
'reasons': '''<h4>Motion: Classification of Schools:</h4><blockquote><p>“Senate calls upon the Ministry of Education, Science and Technology to take immediate action to review the categorization of public secondary schools and to classify all of them as county schools in order to ensure equity in resource allocation and guarantee quality education for all.”</p></blockquote>'''
},
{
'category': 'Health',
'name': 'Cyprian Iringo',
'person': 1574,
'reasons': '''<h4>Petition: Legal recognition of Kenya Association of Private Hospitals by National Hospital Insurance Fund (NHIF):</h4><blockquote><p>“Departmental Committee on Health to consider passing legislation to give KAPH a legal personality to effectively become a bona fide representative of its members in the NHIF Board in order to play a leading role in driving provision of quality healthcare throughout the country.”</p><p>“Compel NHIF to involve all bona fide healthcare providers in consultative discussions on all aspects of service contracts, and to strictly adhere to contracts concluded with healthcare providers and be ready to compensate the provider, among other key issues.”</p></blockquote>'''
},
{
'category': 'Special interests',
'name': 'Isaac Mwaura',
'person': 13129,
'reasons': '''<h4>Petition: Construction of a footbridge on Waiyaki Way to link ABC Place Bus Stop and the National Council for Persons with Disabilities Office, Westlands, Nairobi:</h4><blockquote><ol><li>That, the National Council for Persons with Disabilities (NCPWD) which promotes the rights of persons with disabilities in Kenya amidst disability issues in all aspects of national development is allocated along the busy Waiyaki Way;</li><li>That, the NCPWD offices are located across the ABC Place main stage along Waiyaki Way making the organisation inaccessible when one is arriving from the city.</li><li>Cognisant of the fact that persons with disabilities and in particular those who are physically challenged, or visually impaired who use assisting devices such as wheel-chairs, crutches and white canes encounter challenges when crossing over to and from the Council as well as other disability affiliated organisations operating in the vicinity.</li></ol></blockquote>'''
},
{
'category': 'Security',
'name': 'Fatuma Aden Dullo',
'person': 13125,
'reasons': '''<h4>Motion: Extra-judicial Killings by KWS:</h4><blockquote><ol><li>“Noting with concern that human-wildlife conflict between the Kinna Community of Isiolo County and wildlife at Meru National Park has escalated over the years; Further noting with concern that the above conflict has led to tension between the community and the Kenya Wildlife Service (KWS) which the community accuses of kidnapping, shooting, torturing, wounding and even killing members of the community; Alarmed about the latest alleged report that on 18th May, 2015 KWS rangers clashed with the Kinna Community demonstrators, shot and killed one demonstrator and wounded several others;”</li><li>“The Senate directs the Standing Committee on Land and Natural Resources and the Standing Committee on National Security and Foreign Relations to conduct a fact-finding mission regarding the conflict in the area with immediate effect and report back to the Senate within thirty days.”</li></ol></blockquote>'''
},
{
'category': 'Progressive contributions',
'name': 'Joyce Lay',
'person': 1022,
'reasons': '''<h4>Motion: Translation of the Constitution to Kiswahili:</h4><blockquote><p>“This House urges the National Council for Law Reporting to progressively translate the laws of Kenya into Kiswahili.”</p></blockquote>'''
},
{
'category': 'Business',
'name': 'Tom Kajwang',
'person': 2712,
'reasons': '''<h4>The Companies Bill 2014:</h4><blockquote><p>“We are proposing that any Wanjiku can simply go to the Registrar, get prepared forms, fill them, deposit them with the Registrar and she will have a business vehicle that she can use for trade. This is because the small business people are able to effectively participate in business, that data is captured by the Kenya Revenue Authority (KRA) and everybody who does some business is able to participate in the growth of the nation by paying taxes. So, the Bill creates efficiency, swiftness and is friendly to wananchi because it is simple to understand.” <a href="http://info.mzalendo.com/hansard/sitting/national_assembly/2015-06-30-14-30-00#entry-563209">(Read more)</a></p></blockquote>'''
},
{
'category': 'Land',
'name': 'Mutula Kilonzo Jnr',
'person': 13156,
'reasons': '''<h4>Motion: Historical Land Injustices:</h4><blockquote><p>“This Senate urges the National Land Commission to urgently recommend to the Senate a Bill to address historical land injustices to provide a framework to ensure that land is properly utilized for the economic benefit of the affected communities.”</p></blockquote>'''
}
]
FINALISTS_DICT = {
'2014': {f['person']: f for f in FINALISTS2014},
'2015': {f['person']: f for f in FINALISTS2015},
}
| agpl-3.0 |
apple/llvm-project | lldb/third_party/Python/module/progress/progress.py | 7 | 5623 | #!/usr/bin/env python
from __future__ import print_function
import use_lldb_suite
import six
import sys
import time
class ProgressBar(object):
"""ProgressBar class holds the options of the progress bar.
The options are:
start State from which start the progress. For example, if start is
5 and the end is 10, the progress of this state is 50%
end State in which the progress has terminated.
width --
fill String to use for "filled" used to represent the progress
blank String to use for "filled" used to represent remaining space.
format Format
incremental
"""
light_block = six.unichr(0x2591).encode("utf-8")
solid_block = six.unichr(0x2588).encode("utf-8")
solid_right_arrow = six.unichr(0x25BA).encode("utf-8")
def __init__(self,
start=0,
end=10,
width=12,
fill=six.unichr(0x25C9).encode("utf-8"),
blank=six.unichr(0x25CC).encode("utf-8"),
marker=six.unichr(0x25CE).encode("utf-8"),
format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%',
incremental=True):
super(ProgressBar, self).__init__()
self.start = start
self.end = end
self.width = width
self.fill = fill
self.blank = blank
self.marker = marker
self.format = format
self.incremental = incremental
self.step = 100 / float(width) # fix
self.reset()
def __add__(self, increment):
increment = self._get_progress(increment)
if 100 > self.progress + increment:
self.progress += increment
else:
self.progress = 100
return self
def complete(self):
self.progress = 100
return self
def __str__(self):
progressed = int(self.progress / self.step) # fix
fill = progressed * self.fill
blank = (self.width - progressed) * self.blank
return self.format % {
'fill': fill,
'blank': blank,
'marker': self.marker,
'progress': int(
self.progress)}
__repr__ = __str__
def _get_progress(self, increment):
return float(increment * 100) / self.end
def reset(self):
"""Resets the current progress to the start point"""
self.progress = self._get_progress(self.start)
return self
class AnimatedProgressBar(ProgressBar):
"""Extends ProgressBar to allow you to use it straighforward on a script.
Accepts an extra keyword argument named `stdout` (by default use sys.stdout)
and may be any file-object to which send the progress status.
"""
def __init__(self,
start=0,
end=10,
width=12,
fill=six.unichr(0x25C9).encode("utf-8"),
blank=six.unichr(0x25CC).encode("utf-8"),
marker=six.unichr(0x25CE).encode("utf-8"),
format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%',
incremental=True,
stdout=sys.stdout):
super(
AnimatedProgressBar,
self).__init__(
start,
end,
width,
fill,
blank,
marker,
format,
incremental)
self.stdout = stdout
def show_progress(self):
if hasattr(self.stdout, 'isatty') and self.stdout.isatty():
self.stdout.write('\r')
else:
self.stdout.write('\n')
self.stdout.write(str(self))
self.stdout.flush()
class ProgressWithEvents(AnimatedProgressBar):
"""Extends AnimatedProgressBar to allow you to track a set of events that
cause the progress to move. For instance, in a deletion progress bar, you
can track files that were nuked and files that the user doesn't have access to
"""
def __init__(self,
start=0,
end=10,
width=12,
fill=six.unichr(0x25C9).encode("utf-8"),
blank=six.unichr(0x25CC).encode("utf-8"),
marker=six.unichr(0x25CE).encode("utf-8"),
format='[%(fill)s%(marker)s%(blank)s] %(progress)s%%',
incremental=True,
stdout=sys.stdout):
super(
ProgressWithEvents,
self).__init__(
start,
end,
width,
fill,
blank,
marker,
format,
incremental,
stdout)
self.events = {}
def add_event(self, event):
if event in self.events:
self.events[event] += 1
else:
self.events[event] = 1
def show_progress(self):
isatty = hasattr(self.stdout, 'isatty') and self.stdout.isatty()
if isatty:
self.stdout.write('\r')
else:
self.stdout.write('\n')
self.stdout.write(str(self))
if len(self.events) == 0:
return
self.stdout.write('\n')
for key in list(self.events.keys()):
self.stdout.write(str(key) + ' = ' + str(self.events[key]) + ' ')
if isatty:
self.stdout.write('\033[1A')
self.stdout.flush()
if __name__ == '__main__':
p = AnimatedProgressBar(end=200, width=200)
while True:
p + 5
p.show_progress()
time.sleep(0.3)
if p.progress == 100:
break
print() # new line
| apache-2.0 |
Fyre91/Gesture-Recognition-OpenCV | nestk/deps/opencv/samples/python/cv20squares.py | 6 | 5348 | """
Find Squares in image by finding countours and filtering
"""
#Results slightly different from C version on same images, but is
#otherwise ok
import math
import cv
def angle(pt1, pt2, pt0):
"calculate angle contained by 3 points(x, y)"
dx1 = pt1[0] - pt0[0]
dy1 = pt1[1] - pt0[1]
dx2 = pt2[0] - pt0[0]
dy2 = pt2[1] - pt0[1]
nom = dx1*dx2 + dy1*dy2
denom = math.sqrt( (dx1*dx1 + dy1*dy1) * (dx2*dx2 + dy2*dy2) + 1e-10 )
ang = nom / denom
return ang
def is_square(contour):
"""
Squareness checker
Square contours should:
-have 4 vertices after approximation,
-have relatively large area (to filter out noisy contours)
-be convex.
-have angles between sides close to 90deg (cos(ang) ~0 )
Note: absolute value of an area is used because area may be
positive or negative - in accordance with the contour orientation
"""
area = math.fabs( cv.ContourArea(contour) )
isconvex = cv.CheckContourConvexity(contour)
s = 0
if len(contour) == 4 and area > 1000 and isconvex:
for i in range(1, 4):
# find minimum angle between joint edges (maximum of cosine)
pt1 = contour[i]
pt2 = contour[i-1]
pt0 = contour[i-2]
t = math.fabs(angle(pt0, pt1, pt2))
if s <= t:s = t
# if cosines of all angles are small (all angles are ~90 degree)
# then its a square
if s < 0.3:return True
return False
def find_squares_from_binary( gray ):
"""
use contour search to find squares in binary image
returns list of numpy arrays containing 4 points
"""
squares = []
storage = cv.CreateMemStorage(0)
contours = cv.FindContours(gray, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE, (0,0))
storage = cv.CreateMemStorage(0)
while contours:
#approximate contour with accuracy proportional to the contour perimeter
arclength = cv.ArcLength(contours)
polygon = cv.ApproxPoly( contours, storage, cv.CV_POLY_APPROX_DP, arclength * 0.02, 0)
if is_square(polygon):
squares.append(polygon[0:4])
contours = contours.h_next()
return squares
def find_squares4(color_img):
"""
Finds multiple squares in image
Steps:
-Use Canny edge to highlight contours, and dilation to connect
the edge segments.
-Threshold the result to binary edge tokens
-Use cv.FindContours: returns a cv.CvSequence of cv.CvContours
-Filter each candidate: use Approx poly, keep only contours with 4 vertices,
enough area, and ~90deg angles.
Return all squares contours in one flat list of arrays, 4 x,y points each.
"""
#select even sizes only
width, height = (color_img.width & -2, color_img.height & -2 )
timg = cv.CloneImage( color_img ) # make a copy of input image
gray = cv.CreateImage( (width,height), 8, 1 )
# select the maximum ROI in the image
cv.SetImageROI( timg, (0, 0, width, height) )
# down-scale and upscale the image to filter out the noise
pyr = cv.CreateImage( (width/2, height/2), 8, 3 )
cv.PyrDown( timg, pyr, 7 )
cv.PyrUp( pyr, timg, 7 )
tgray = cv.CreateImage( (width,height), 8, 1 )
squares = []
# Find squares in every color plane of the image
# Two methods, we use both:
# 1. Canny to catch squares with gradient shading. Use upper threshold
# from slider, set the lower to 0 (which forces edges merging). Then
# dilate canny output to remove potential holes between edge segments.
# 2. Binary thresholding at multiple levels
N = 11
for c in [0, 1, 2]:
#extract the c-th color plane
cv.SetImageCOI( timg, c+1 );
cv.Copy( timg, tgray, None );
cv.Canny( tgray, gray, 0, 50, 5 )
cv.Dilate( gray, gray)
squares = squares + find_squares_from_binary( gray )
# Look for more squares at several threshold levels
for l in range(1, N):
cv.Threshold( tgray, gray, (l+1)*255/N, 255, cv.CV_THRESH_BINARY )
squares = squares + find_squares_from_binary( gray )
return squares
RED = (0,0,255)
GREEN = (0,255,0)
def draw_squares( color_img, squares ):
"""
Squares is py list containing 4-pt numpy arrays. Step through the list
and draw a polygon for each 4-group
"""
color, othercolor = RED, GREEN
for square in squares:
cv.PolyLine(color_img, [square], True, color, 3, cv.CV_AA, 0)
color, othercolor = othercolor, color
cv.ShowImage(WNDNAME, color_img)
WNDNAME = "Squares Demo"
def main():
"""Open test color images, create display window, start the search"""
cv.NamedWindow(WNDNAME, 1)
for name in [ "../c/pic%d.png" % i for i in [1, 2, 3, 4, 5, 6] ]:
img0 = cv.LoadImage(name, 1)
try:
img0
except ValueError:
print "Couldn't load %s\n" % name
continue
# slider deleted from C version, same here and use fixed Canny param=50
img = cv.CloneImage(img0)
cv.ShowImage(WNDNAME, img)
# force the image processing
draw_squares( img, find_squares4( img ) )
# wait for key.
if cv.WaitKey(-1) % 0x100 == 27:
break
if __name__ == "__main__":
main()
| lgpl-3.0 |
ader1990/rasphack-watchout | tests.py | 3 | 15027 | import unittest
import doctest
import serial
from itertools import chain
import pyfirmata
from pyfirmata import mockup
from pyfirmata.boards import BOARDS
from pyfirmata.util import str_to_two_byte_iter, to_two_bytes
# Messages todo left:
# type command channel first byte second byte
# ---------------------------------------------------------------------------
# set pin mode(I/O) 0xF4 pin # (0-127) pin state(0=in)
# system reset 0xFF
class BoardBaseTest(unittest.TestCase):
def setUp(self):
# Test with the MockupSerial so no real connection is needed
pyfirmata.pyfirmata.serial.Serial = mockup.MockupSerial
self.board = pyfirmata.Board('', BOARDS['arduino'])
self.board._stored_data = [] # FIXME How can it be that a fresh instance sometimes still contains data?
class TestBoardMessages(BoardBaseTest):
# TODO Test layout of Board Mega
def assert_serial(self, *list_of_chrs):
res = self.board.sp.read()
serial_msg = res
while res:
res = self.board.sp.read()
serial_msg += res
self.assertEqual(''.join(list(list_of_chrs)), serial_msg)
# First test the handlers
def test_handle_analog_message(self):
self.board.analog[3].reporting = True
self.assertEqual(self.board.analog[3].read(), None)
# This sould set it correctly. 1023 (127, 7 in to 7 bit bytes) is the
# max value an analog pin will send and it should result in a value 1
self.board._handle_analog_message(3, 127, 7)
self.assertEqual(self.board.analog[3].read(), 1.0)
def test_handle_digital_message(self):
# A digital message sets the value for a whole port. We will set pin
# 5 (That is on port 0) to 1 to test if this is working.
self.board.digital_ports[0].reporting = True
self.board.digital[5]._mode = 0 # Set it to input
# Create the mask
mask = 0
mask |= 1 << 5 # set the bit for pin 5 to to 1
self.assertEqual(self.board.digital[5].read(), None)
self.board._handle_digital_message(0, mask % 128, mask >> 7)
self.assertEqual(self.board.digital[5].read(), True)
def test_handle_report_version(self):
self.assertEqual(self.board.firmata_version, None)
self.board._handle_report_version(2, 1)
self.assertEqual(self.board.firmata_version, (2, 1))
def test_handle_report_firmware(self):
self.assertEqual(self.board.firmware, None)
data = [2, 1] + str_to_two_byte_iter('Firmware_name')
self.board._handle_report_firmware(*data)
self.assertEqual(self.board.firmware, 'Firmware_name')
self.assertEqual(self.board.firmware_version, (2, 1))
# type command channel first byte second byte
# ---------------------------------------------------------------------------
# analog I/O message 0xE0 pin # LSB(bits 0-6) MSB(bits 7-13)
def test_incoming_analog_message(self):
self.assertEqual(self.board.analog[4].read(), None)
self.assertEqual(self.board.analog[4].reporting, False)
# Should do nothing as the pin isn't set to report
self.board.sp.write([chr(pyfirmata.ANALOG_MESSAGE + 4), chr(127), chr(7)])
self.board.iterate()
self.assertEqual(self.board.analog[4].read(), None)
self.board.analog[4].enable_reporting()
self.board.sp.clear()
# This should set analog port 4 to 1
self.board.sp.write([chr(pyfirmata.ANALOG_MESSAGE + 4), chr(127), chr(7)])
self.board.iterate()
self.assertEqual(self.board.analog[4].read(), 1.0)
self.board._stored_data = []
# type command channel first byte second byte
# ---------------------------------------------------------------------------
# digital I/O message 0x90 port LSB(bits 0-6) MSB(bits 7-13)
def test_incoming_digital_message(self):
# A digital message sets the value for a whole port. We will set pin
# 9 (on port 1) to 1 to test if this is working.
self.board.digital[9].mode = pyfirmata.INPUT
self.board.sp.clear() # clear mode sent over the wire.
# Create the mask
mask = 0
mask |= 1 << (9 - 8) # set the bit for pin 9 to to 1
self.assertEqual(self.board.digital[9].read(), None)
self.board.sp.write([chr(pyfirmata.DIGITAL_MESSAGE + 1), chr(mask % 128), chr(mask >> 7)])
self.board.iterate()
self.assertEqual(self.board.digital[9].read(), True)
# version report format
# -------------------------------------------------
# 0 version report header (0xF9) (MIDI Undefined)
# 1 major version (0-127)
# 2 minor version (0-127)
def test_incoming_report_version(self):
self.assertEqual(self.board.firmata_version, None)
self.board.sp.write([chr(pyfirmata.REPORT_VERSION), chr(2), chr(1)])
self.board.iterate()
self.assertEqual(self.board.firmata_version, (2, 1))
# Receive Firmware Name and Version (after query)
# 0 START_SYSEX (0xF0)
# 1 queryFirmware (0x79)
# 2 major version (0-127)
# 3 minor version (0-127)
# 4 first 7-bits of firmware name
# 5 second 7-bits of firmware name
# x ...for as many bytes as it needs)
# 6 END_SYSEX (0xF7)
def test_incoming_report_firmware(self):
self.assertEqual(self.board.firmware, None)
self.assertEqual(self.board.firmware_version, None)
msg = [chr(pyfirmata.START_SYSEX),
chr(pyfirmata.REPORT_FIRMWARE),
chr(2),
chr(1)] + str_to_two_byte_iter('Firmware_name') + \
[chr(pyfirmata.END_SYSEX)]
self.board.sp.write(msg)
self.board.iterate()
self.assertEqual(self.board.firmware, 'Firmware_name')
self.assertEqual(self.board.firmware_version, (2, 1))
# type command channel first byte second byte
# ---------------------------------------------------------------------------
# report analog pin 0xC0 pin # disable/enable(0/1) - n/a -
def test_report_analog(self):
self.board.analog[1].enable_reporting()
self.assert_serial(chr(0xC0 + 1), chr(1))
self.assertTrue(self.board.analog[1].reporting)
self.board.analog[1].disable_reporting()
self.assert_serial(chr(0xC0 + 1), chr(0))
self.assertFalse(self.board.analog[1].reporting)
# type command channel first byte second byte
# ---------------------------------------------------------------------------
# report digital port 0xD0 port disable/enable(0/1) - n/a -
def test_report_digital(self):
# This should enable reporting of whole port 1
self.board.digital[8]._mode = pyfirmata.INPUT # Outputs can't report
self.board.digital[8].enable_reporting()
self.assert_serial(chr(0xD0 + 1), chr(1))
self.assertTrue(self.board.digital_ports[1].reporting)
self.board.digital[8].disable_reporting()
self.assert_serial(chr(0xD0 + 1), chr(0))
# Generic Sysex Message
# 0 START_SYSEX (0xF0)
# 1 sysex command (0x00-0x7F)
# x between 0 and MAX_DATA_BYTES 7-bit bytes of arbitrary data
# last END_SYSEX (0xF7)
def test_send_sysex_message(self):
# 0x79 is queryFirmware, but that doesn't matter for now
self.board.send_sysex(0x79, [1, 2, 3])
sysex = (chr(0xF0), chr(0x79), chr(1), chr(2), chr(3), chr(0xF7))
self.assert_serial(*sysex)
def test_send_sysex_to_big_data(self):
self.assertRaises(ValueError, self.board.send_sysex, 0x79, [256, 1])
def test_receive_sysex_message(self):
sysex = (chr(0xF0), chr(0x79), chr(2), chr(1), 'a', '\x00', 'b',
'\x00', 'c', '\x00', chr(0xF7))
self.board.sp.write(sysex)
while len(self.board.sp):
self.board.iterate()
self.assertEqual(self.board.firmware_version, (2, 1))
self.assertEqual(self.board.firmware, 'abc')
def test_too_much_data(self):
"""
When we send random bytes, before or after a command, they should be
ignored to prevent cascading errors when missing a byte.
"""
self.board.analog[4].enable_reporting()
self.board.sp.clear()
# Crap
self.board.sp.write([chr(i) for i in range(10)])
# This should set analog port 4 to 1
self.board.sp.write([chr(pyfirmata.ANALOG_MESSAGE + 4), chr(127), chr(7)])
# Crap
self.board.sp.write([chr(10-i) for i in range(10)])
while len(self.board.sp):
self.board.iterate()
self.assertEqual(self.board.analog[4].read(), 1.0)
# Servo config
# --------------------
# 0 START_SYSEX (0xF0)
# 1 SERVO_CONFIG (0x70)
# 2 pin number (0-127)
# 3 minPulse LSB (0-6)
# 4 minPulse MSB (7-13)
# 5 maxPulse LSB (0-6)
# 6 maxPulse MSB (7-13)
# 7 END_SYSEX (0xF7)
#
# then sets angle
# 8 analog I/O message (0xE0)
# 9 angle LSB
# 10 angle MSB
def test_servo_config(self):
self.board.servo_config(2)
data = chain([chr(0xF0), chr(0x70), chr(2)], to_two_bytes(544),
to_two_bytes(2400), chr(0xF7), chr(0xE0 + 2), chr(0), chr(0))
self.assert_serial(*data)
def test_servo_config_min_max_pulse(self):
self.board.servo_config(2, 600, 2000)
data = chain([chr(0xF0), chr(0x70), chr(2)], to_two_bytes(600),
to_two_bytes(2000), chr(0xF7), chr(0xE0 + 2), chr(0), chr(0))
self.assert_serial(*data)
def test_servo_config_min_max_pulse_angle(self):
self.board.servo_config(2, 600, 2000, angle=90)
data = chain([chr(0xF0), chr(0x70), chr(2)], to_two_bytes(600),
to_two_bytes(2000), chr(0xF7))
angle_set = [chr(0xE0 + 2), chr(90 % 128),
chr(90 >> 7)] # Angle set happens through analog message
data = list(data) + angle_set
self.assert_serial(*data)
def test_servo_config_invalid_pin(self):
self.assertRaises(IOError, self.board.servo_config, 1)
def test_set_mode_servo(self):
p = self.board.digital[2]
p.mode = pyfirmata.SERVO
data = chain([chr(0xF0), chr(0x70), chr(2)], to_two_bytes(544),
to_two_bytes(2400), chr(0xF7), chr(0xE0 + 2), chr(0), chr(0))
self.assert_serial(*data)
class TestBoardLayout(BoardBaseTest):
def test_layout_arduino(self):
self.assertEqual(len(BOARDS['arduino']['digital']), len(self.board.digital))
self.assertEqual(len(BOARDS['arduino']['analog']), len(self.board.analog))
def test_layout_arduino_mega(self):
pyfirmata.pyfirmata.serial.Serial = mockup.MockupSerial
mega = pyfirmata.Board('', BOARDS['arduino_mega'])
self.assertEqual(len(BOARDS['arduino_mega']['digital']), len(mega.digital))
self.assertEqual(len(BOARDS['arduino_mega']['analog']), len(mega.analog))
def test_pwm_layout(self):
pins = []
for pin in self.board.digital:
if pin.PWM_CAPABLE:
pins.append(self.board.get_pin('d:%d:p' % pin.pin_number))
for pin in pins:
self.assertEqual(pin.mode, pyfirmata.PWM)
self.assertTrue(pin.pin_number in BOARDS['arduino']['pwm'])
self.assertTrue(len(pins) == len(BOARDS['arduino']['pwm']))
def test_get_pin_digital(self):
pin = self.board.get_pin('d:13:o')
self.assertEqual(pin.pin_number, 13)
self.assertEqual(pin.mode, pyfirmata.OUTPUT)
self.assertEqual(pin.port.port_number, 1)
self.assertEqual(pin.port.reporting, False)
def test_get_pin_analog(self):
pin = self.board.get_pin('a:5:i')
self.assertEqual(pin.pin_number, 5)
self.assertEqual(pin.reporting, True)
self.assertEqual(pin.value, None)
def tearDown(self):
self.board.exit()
pyfirmata.serial.Serial = serial.Serial
class TestMockupBoardLayout(TestBoardLayout, TestBoardMessages):
"""
TestMockupBoardLayout is subclassed from TestBoardLayout and
TestBoardMessages as it should pass the same tests, but with the
MockupBoard.
"""
def setUp(self):
self.board = mockup.MockupBoard('test', BOARDS['arduino'])
class RegressionTests(BoardBaseTest):
def test_correct_digital_input_first_pin_issue_9(self):
"""
The first pin on the port would always be low, even if the mask said
it to be high.
"""
pin = self.board.get_pin('d:8:i')
mask = 0
mask |= 1 << 0 # set pin 0 high
self.board._handle_digital_message(pin.port.port_number,
mask % 128, mask >> 7)
self.assertEqual(pin.value, True)
def test_handle_digital_inputs(self):
"""
Test if digital inputs are correctly updated.
"""
for i in range(8, 16): # pins of port 1
if not bool(i%2) and i != 14: # all even pins
self.board.digital[i].mode = pyfirmata.INPUT
self.assertEqual(self.board.digital[i].value, None)
mask = 0
# Set the mask high for the first 4 pins
for i in range(4):
mask |= 1 << i
self.board._handle_digital_message(1, mask % 128, mask >> 7)
self.assertEqual(self.board.digital[8].value, True)
self.assertEqual(self.board.digital[9].value, None)
self.assertEqual(self.board.digital[10].value, True)
self.assertEqual(self.board.digital[11].value, None)
self.assertEqual(self.board.digital[12].value, False)
self.assertEqual(self.board.digital[13].value, None)
board_messages = unittest.TestLoader().loadTestsFromTestCase(TestBoardMessages)
board_layout = unittest.TestLoader().loadTestsFromTestCase(TestBoardLayout)
regression = unittest.TestLoader().loadTestsFromTestCase(RegressionTests)
default = unittest.TestSuite([board_messages, board_layout, regression])
mockup_suite = unittest.TestLoader().loadTestsFromTestCase(TestMockupBoardLayout)
if __name__ == '__main__':
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-m", "--mockup", dest="mockup", action="store_true",
help="Also run the mockup tests")
options, args = parser.parse_args()
if not options.mockup:
print "Running normal suite. Also consider running the mockup (-m, --mockup) suite"
unittest.TextTestRunner(verbosity=3).run(default)
from pyfirmata import util
print "Running doctests for pyfirmata.util. (No output = No errors)"
doctest.testmod(util)
print "Done running doctests"
if options.mockup:
print "Running the mockup test suite"
unittest.TextTestRunner(verbosity=2).run(mockup_suite)
| mit |
pernici/sympy | sympy/polys/tests/test_orthopolys.py | 2 | 3048 | """Tests for efficient functions for generating orthogonal polynomials. """
from sympy import Poly, Rational as Q
from sympy.utilities.pytest import raises
from sympy.polys.orthopolys import (
chebyshevt_poly,
chebyshevu_poly,
hermite_poly,
legendre_poly,
laguerre_poly,
)
from sympy.abc import x
def test_chebyshevt_poly():
raises(ValueError, "chebyshevt_poly(-1, x)")
assert chebyshevt_poly(1, x, polys=True) == Poly(x)
assert chebyshevt_poly(0, x) == 1
assert chebyshevt_poly(1, x) == x
assert chebyshevt_poly(2, x) == 2*x**2 - 1
assert chebyshevt_poly(3, x) == 4*x**3 - 3*x
assert chebyshevt_poly(4, x) == 8*x**4 - 8*x**2 + 1
assert chebyshevt_poly(5, x) == 16*x**5 - 20*x**3 + 5*x
assert chebyshevt_poly(6, x) == 32*x**6 - 48*x**4 + 18*x**2 - 1
def test_chebyshevu_poly():
raises(ValueError, "chebyshevu_poly(-1, x)")
assert chebyshevu_poly(1, x, polys=True) == Poly(2*x)
assert chebyshevu_poly(0, x) == 1
assert chebyshevu_poly(1, x) == 2*x
assert chebyshevu_poly(2, x) == 4*x**2 - 1
assert chebyshevu_poly(3, x) == 8*x**3 - 4*x
assert chebyshevu_poly(4, x) == 16*x**4 - 12*x**2 + 1
assert chebyshevu_poly(5, x) == 32*x**5 - 32*x**3 + 6*x
assert chebyshevu_poly(6, x) == 64*x**6 - 80*x**4 + 24*x**2 - 1
def test_hermite_poly():
raises(ValueError, "hermite_poly(-1, x)")
assert hermite_poly(1, x, polys=True) == Poly(2*x)
assert hermite_poly(0, x) == 1
assert hermite_poly(1, x) == 2*x
assert hermite_poly(2, x) == 4*x**2 - 2
assert hermite_poly(3, x) == 8*x**3 - 12*x
assert hermite_poly(4, x) == 16*x**4 - 48*x**2 + 12
assert hermite_poly(5, x) == 32*x**5 - 160*x**3 + 120*x
assert hermite_poly(6, x) == 64*x**6 - 480*x**4 + 720*x**2 - 120
def test_legendre_poly():
raises(ValueError, "legendre_poly(-1, x)")
assert legendre_poly(1, x, polys=True) == Poly(x)
assert legendre_poly(0, x) == 1
assert legendre_poly(1, x) == x
assert legendre_poly(2, x) == Q(3,2)*x**2 - Q(1,2)
assert legendre_poly(3, x) == Q(5,2)*x**3 - Q(3,2)*x
assert legendre_poly(4, x) == Q(35,8)*x**4 - Q(30,8)*x**2 + Q(3,8)
assert legendre_poly(5, x) == Q(63,8)*x**5 - Q(70,8)*x**3 + Q(15,8)*x
assert legendre_poly(6, x) == Q(231,16)*x**6 - Q(315,16)*x**4 + Q(105,16)*x**2 - Q(5,16)
def test_laguerre_poly():
raises(ValueError, "laguerre_poly(-1, x)")
assert laguerre_poly(1, x, polys=True) == Poly(-x + 1)
assert laguerre_poly(0, x) == 1
assert laguerre_poly(1, x) == -x + 1
assert laguerre_poly(2, x) == Q(1,2)*x**2 - Q(4,2)*x + 1
assert laguerre_poly(3, x) == -Q(1,6)*x**3 + Q(9,6)*x**2 - Q(18,6)*x + 1
assert laguerre_poly(4, x) == Q(1,24)*x**4 - Q(16,24)*x**3 + Q(72,24)*x**2 - Q(96,24)*x + 1
assert laguerre_poly(5, x) == -Q(1,120)*x**5 + Q(25,120)*x**4 - Q(200,120)*x**3 + Q(600,120)*x**2 - Q(600,120)*x + 1
assert laguerre_poly(6, x) == Q(1,720)*x**6 - Q(36,720)*x**5 + Q(450,720)*x**4 - Q(2400,720)*x**3 + Q(5400,720)*x**2 - Q(4320,720)*x + 1
| bsd-3-clause |
Emergya/icm-openedx-educamadrid-platform-basic | lms/djangoapps/mailing/management/commands/mailchimp_sync_announcements.py | 155 | 2534 | """
Synchronizes the announcement list with all active students.
"""
import logging
from optparse import make_option
from django.core.management.base import BaseCommand, CommandError
from django.contrib.auth.models import User
from .mailchimp_sync_course import (
connect_mailchimp, get_cleaned,
get_subscribed, get_unsubscribed,
subscribe_with_data
)
log = logging.getLogger('edx.mailchimp')
class Command(BaseCommand):
"""
Synchronizes the announcement list with all active students.
"""
args = '<mailchimp_key mailchimp_list course_id>'
help = 'Synchronizes the announcement list with all active students.'
option_list = BaseCommand.option_list + (
make_option('--key', action='store', help='mailchimp api key'),
make_option('--list', action='store', dest='list_id',
help='mailchimp list id'),
)
def parse_options(self, options):
"""Parses `options` of the command."""
if not options['key']:
raise CommandError('missing key')
if not options['list_id']:
raise CommandError('missing list id')
return (options['key'], options['list_id'])
def handle(self, *args, **options):
key, list_id = self.parse_options(options)
log.info('Syncronizing announcement mailing list')
mailchimp = connect_mailchimp(key)
subscribed = get_subscribed(mailchimp, list_id)
unsubscribed = get_unsubscribed(mailchimp, list_id)
cleaned = get_cleaned(mailchimp, list_id)
non_subscribed = unsubscribed.union(cleaned)
enrolled = get_enrolled()
exclude = subscribed.union(non_subscribed)
to_subscribe = get_data(enrolled, exclude=exclude)
subscribe_with_data(mailchimp, list_id, to_subscribe)
def get_enrolled():
"""
Filter out all users who signed up via a Microsite, which UserSignupSource tracks
"""
## TODO (Feanil) This grabs all inactive students and MUST be changed (or, could exclude inactive users in get_data)
return User.objects.raw('SELECT * FROM auth_user where id not in (SELECT user_id from student_usersignupsource)')
def get_data(users, exclude=None):
"""
users: set of Django users
exclude [optional]: set of Django users to exclude
returns: {'EMAIL': u.email} for all users in users less those in `exclude`
"""
exclude = exclude if exclude else set()
emails = (u.email for u in users)
return ({'EMAIL': e} for e in emails if e not in exclude)
| agpl-3.0 |
holtwick/pyxer | src/pyxer/template/genshi/filters/html.py | 2 | 16526 | # -*- coding: utf-8 -*-
#
# Copyright (C) 2006-2008 Edgewall Software
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at http://genshi.edgewall.org/wiki/License.
#
# This software consists of voluntary contributions made by many
# individuals. For the exact contribution history, see the revision
# history and logs, available at http://genshi.edgewall.org/log/.
"""Implementation of a number of stream filters."""
try:
set
except NameError:
from sets import ImmutableSet as frozenset
from sets import Set as set
import re
from pyxer.template.genshi.core import Attrs, QName, stripentities
from pyxer.template.genshi.core import END, START, TEXT, COMMENT
__all__ = ['HTMLFormFiller', 'HTMLSanitizer']
__docformat__ = 'restructuredtext en'
class HTMLFormFiller(object):
"""A stream filter that can populate HTML forms from a dictionary of values.
>>> from genshi.input import HTML
>>> html = HTML('''<form>
... <p><input type="text" name="foo" /></p>
... </form>''')
>>> filler = HTMLFormFiller(data={'foo': 'bar'})
>>> print html | filler
<form>
<p><input type="text" name="foo" value="bar"/></p>
</form>
"""
# TODO: only select the first radio button, and the first select option
# (if not in a multiple-select)
# TODO: only apply to elements in the XHTML namespace (or no namespace)?
def __init__(self, name=None, id=None, data=None):
"""Create the filter.
:param name: The name of the form that should be populated. If this
parameter is given, only forms where the ``name`` attribute
value matches the parameter are processed.
:param id: The ID of the form that should be populated. If this
parameter is given, only forms where the ``id`` attribute
value matches the parameter are processed.
:param data: The dictionary of form values, where the keys are the names
of the form fields, and the values are the values to fill
in.
"""
self.name = name
self.id = id
if data is None:
data = {}
self.data = data
def __call__(self, stream):
"""Apply the filter to the given stream.
:param stream: the markup event stream to filter
"""
in_form = in_select = in_option = in_textarea = False
select_value = option_value = textarea_value = None
option_start = None
option_text = []
no_option_value = False
for kind, data, pos in stream:
if kind is START:
tag, attrs = data
tagname = tag.localname
if tagname == 'form' and (
self.name and attrs.get('name') == self.name or
self.id and attrs.get('id') == self.id or
not (self.id or self.name)):
in_form = True
elif in_form:
if tagname == 'input':
type = attrs.get('type')
if type in ('checkbox', 'radio'):
name = attrs.get('name')
if name and name in self.data:
value = self.data[name]
declval = attrs.get('value')
checked = False
if isinstance(value, (list, tuple)):
if declval:
checked = declval in [unicode(v) for v
in value]
else:
checked = bool(filter(None, value))
else:
if declval:
checked = declval == unicode(value)
elif type == 'checkbox':
checked = bool(value)
if checked:
attrs |= [(QName('checked'), 'checked')]
elif 'checked' in attrs:
attrs -= 'checked'
elif type in (None, 'hidden', 'text'):
name = attrs.get('name')
if name and name in self.data:
value = self.data[name]
if isinstance(value, (list, tuple)):
value = value[0]
if value is not None:
attrs |= [(QName('value'), unicode(value))]
elif tagname == 'select':
name = attrs.get('name')
if name in self.data:
select_value = self.data[name]
in_select = True
elif tagname == 'textarea':
name = attrs.get('name')
if name in self.data:
textarea_value = self.data.get(name)
if isinstance(textarea_value, (list, tuple)):
textarea_value = textarea_value[0]
in_textarea = True
elif in_select and tagname == 'option':
option_start = kind, data, pos
option_value = attrs.get('value')
if option_value is None:
no_option_value = True
option_value = ''
in_option = True
continue
yield kind, (tag, attrs), pos
elif in_form and kind is TEXT:
if in_select and in_option:
if no_option_value:
option_value += data
option_text.append((kind, data, pos))
continue
elif in_textarea:
continue
yield kind, data, pos
elif in_form and kind is END:
tagname = data.localname
if tagname == 'form':
in_form = False
elif tagname == 'select':
in_select = False
select_value = None
elif in_select and tagname == 'option':
if isinstance(select_value, (tuple, list)):
selected = option_value in [unicode(v) for v
in select_value]
else:
selected = option_value == unicode(select_value)
okind, (tag, attrs), opos = option_start
if selected:
attrs |= [(QName('selected'), 'selected')]
elif 'selected' in attrs:
attrs -= 'selected'
yield okind, (tag, attrs), opos
if option_text:
for event in option_text:
yield event
in_option = False
no_option_value = False
option_start = option_value = None
option_text = []
elif tagname == 'textarea':
if textarea_value:
yield TEXT, unicode(textarea_value), pos
in_textarea = False
yield kind, data, pos
else:
yield kind, data, pos
class HTMLSanitizer(object):
"""A filter that removes potentially dangerous HTML tags and attributes
from the stream.
>>> from genshi import HTML
>>> html = HTML('<div><script>alert(document.cookie)</script></div>')
>>> print html | HTMLSanitizer()
<div/>
The default set of safe tags and attributes can be modified when the filter
is instantiated. For example, to allow inline ``style`` attributes, the
following instantation would work:
>>> html = HTML('<div style="background: #000"></div>')
>>> sanitizer = HTMLSanitizer(safe_attrs=HTMLSanitizer.SAFE_ATTRS | set(['style']))
>>> print html | sanitizer
<div style="background: #000"/>
Note that even in this case, the filter *does* attempt to remove dangerous
constructs from style attributes:
>>> html = HTML('<div style="background: url(javascript:void); color: #000"></div>')
>>> print html | sanitizer
<div style="color: #000"/>
This handles HTML entities, unicode escapes in CSS and Javascript text, as
well as a lot of other things. However, the style tag is still excluded by
default because it is very hard for such sanitizing to be completely safe,
especially considering how much error recovery current web browsers perform.
:warn: Note that this special processing of CSS is currently only applied to
style attributes, **not** style elements.
"""
SAFE_TAGS = frozenset(['a', 'abbr', 'acronym', 'address', 'area', 'b',
'big', 'blockquote', 'br', 'button', 'caption', 'center', 'cite',
'code', 'col', 'colgroup', 'dd', 'del', 'dfn', 'dir', 'div', 'dl', 'dt',
'em', 'fieldset', 'font', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
'hr', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'map',
'menu', 'ol', 'optgroup', 'option', 'p', 'pre', 'q', 's', 'samp',
'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'table',
'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'tr', 'tt', 'u',
'ul', 'var'])
SAFE_ATTRS = frozenset(['abbr', 'accept', 'accept-charset', 'accesskey',
'action', 'align', 'alt', 'axis', 'bgcolor', 'border', 'cellpadding',
'cellspacing', 'char', 'charoff', 'charset', 'checked', 'cite', 'class',
'clear', 'cols', 'colspan', 'color', 'compact', 'coords', 'datetime',
'dir', 'disabled', 'enctype', 'for', 'frame', 'headers', 'height',
'href', 'hreflang', 'hspace', 'id', 'ismap', 'label', 'lang',
'longdesc', 'maxlength', 'media', 'method', 'multiple', 'name',
'nohref', 'noshade', 'nowrap', 'prompt', 'readonly', 'rel', 'rev',
'rows', 'rowspan', 'rules', 'scope', 'selected', 'shape', 'size',
'span', 'src', 'start', 'summary', 'tabindex', 'target', 'title',
'type', 'usemap', 'valign', 'value', 'vspace', 'width'])
SAFE_SCHEMES = frozenset(['file', 'ftp', 'http', 'https', 'mailto', None])
URI_ATTRS = frozenset(['action', 'background', 'dynsrc', 'href', 'lowsrc',
'src'])
def __init__(self, safe_tags=SAFE_TAGS, safe_attrs=SAFE_ATTRS,
safe_schemes=SAFE_SCHEMES, uri_attrs=URI_ATTRS):
"""Create the sanitizer.
The exact set of allowed elements and attributes can be configured.
:param safe_tags: a set of tag names that are considered safe
:param safe_attrs: a set of attribute names that are considered safe
:param safe_schemes: a set of URI schemes that are considered safe
:param uri_attrs: a set of names of attributes that contain URIs
"""
self.safe_tags = safe_tags
"The set of tag names that are considered safe."
self.safe_attrs = safe_attrs
"The set of attribute names that are considered safe."
self.uri_attrs = uri_attrs
"The set of names of attributes that may contain URIs."
self.safe_schemes = safe_schemes
"The set of URI schemes that are considered safe."
def __call__(self, stream):
"""Apply the filter to the given stream.
:param stream: the markup event stream to filter
"""
waiting_for = None
for kind, data, pos in stream:
if kind is START:
if waiting_for:
continue
tag, attrs = data
if tag not in self.safe_tags:
waiting_for = tag
continue
new_attrs = []
for attr, value in attrs:
value = stripentities(value)
if attr not in self.safe_attrs:
continue
elif attr in self.uri_attrs:
# Don't allow URI schemes such as "javascript:"
if not self.is_safe_uri(value):
continue
elif attr == 'style':
# Remove dangerous CSS declarations from inline styles
decls = self.sanitize_css(value)
if not decls:
continue
value = '; '.join(decls)
new_attrs.append((attr, value))
yield kind, (tag, Attrs(new_attrs)), pos
elif kind is END:
tag = data
if waiting_for:
if waiting_for == tag:
waiting_for = None
else:
yield kind, data, pos
elif kind is not COMMENT:
if not waiting_for:
yield kind, data, pos
def is_safe_uri(self, uri):
"""Determine whether the given URI is to be considered safe for
inclusion in the output.
The default implementation checks whether the scheme of the URI is in
the set of allowed URIs (`safe_schemes`).
>>> sanitizer = HTMLSanitizer()
>>> sanitizer.is_safe_uri('http://example.org/')
True
>>> sanitizer.is_safe_uri('javascript:alert(document.cookie)')
False
:param uri: the URI to check
:return: `True` if the URI can be considered safe, `False` otherwise
:rtype: `bool`
:since: version 0.4.3
"""
if ':' not in uri:
return True # This is a relative URI
chars = [char for char in uri.split(':', 1)[0] if char.isalnum()]
return ''.join(chars).lower() in self.safe_schemes
def sanitize_css(self, text):
"""Remove potentially dangerous property declarations from CSS code.
In particular, properties using the CSS ``url()`` function with a scheme
that is not considered safe are removed:
>>> sanitizer = HTMLSanitizer()
>>> sanitizer.sanitize_css(u'''
... background: url(javascript:alert("foo"));
... color: #000;
... ''')
[u'color: #000']
Also, the proprietary Internet Explorer function ``expression()`` is
always stripped:
>>> sanitizer.sanitize_css(u'''
... background: #fff;
... color: #000;
... width: e/**/xpression(alert("foo"));
... ''')
[u'background: #fff', u'color: #000']
:param text: the CSS text; this is expected to be `unicode` and to not
contain any character or numeric references
:return: a list of declarations that are considered safe
:rtype: `list`
:since: version 0.4.3
"""
decls = []
text = self._strip_css_comments(self._replace_unicode_escapes(text))
for decl in filter(None, text.split(';')):
decl = decl.strip()
if not decl:
continue
is_evil = False
if 'expression' in decl:
is_evil = True
for match in re.finditer(r'url\s*\(([^)]+)', decl):
if not self.is_safe_uri(match.group(1)):
is_evil = True
break
if not is_evil:
decls.append(decl.strip())
return decls
_NORMALIZE_NEWLINES = re.compile(r'\r\n').sub
_UNICODE_ESCAPE = re.compile(r'\\([0-9a-fA-F]{1,6})\s?').sub
def _replace_unicode_escapes(self, text):
def _repl(match):
return unichr(int(match.group(1), 16))
return self._UNICODE_ESCAPE(_repl, self._NORMALIZE_NEWLINES('\n', text))
_CSS_COMMENTS = re.compile(r'/\*.*?\*/').sub
def _strip_css_comments(self, text):
return self._CSS_COMMENTS('', text)
| mit |
rainest/dance-partner-matching | networkx/readwrite/tests/test_leda.py | 2 | 1634 | #!/usr/bin/env python
import copy
from nose.tools import *
import networkx as nx
import os,tempfile
class TestLEDA(object):
def test_parse_leda(self):
data="""#header section \nLEDA.GRAPH \nstring\nint\n-1\n#nodes section\n5 \n|{v1}| \n|{v2}| \n|{v3}| \n|{v4}| \n|{v5}| \n\n#edges section\n7 \n1 2 0 |{4}| \n1 3 0 |{3}| \n2 3 0 |{2}| \n3 4 0 |{3}| \n3 5 0 |{7}| \n4 5 0 |{6}| \n5 1 0 |{foo}|"""
G=nx.parse_leda(data)
G=nx.parse_leda(data.split('\n'))
assert_equal(sorted(G.nodes()),
['v1', 'v2', 'v3', 'v4', 'v5'])
assert_equal([e for e in sorted(G.edges(data=True))],
[('v1', 'v2', {'label': '4'}),
('v1', 'v3', {'label': '3'}),
('v2', 'v3', {'label': '2'}),
('v3', 'v4', {'label': '3'}),
('v3', 'v5', {'label': '7'}),
('v4', 'v5', {'label': '6'}),
('v5', 'v1', {'label': 'foo'})])
def test_read_LEDA(self):
data="""#header section \nLEDA.GRAPH \nstring\nint\n-1\n#nodes section\n5 \n|{v1}| \n|{v2}| \n|{v3}| \n|{v4}| \n|{v5}| \n\n#edges section\n7 \n1 2 0 |{4}| \n1 3 0 |{3}| \n2 3 0 |{2}| \n3 4 0 |{3}| \n3 5 0 |{7}| \n4 5 0 |{6}| \n5 1 0 |{foo}|"""
G=nx.parse_leda(data)
(fd,fname)=tempfile.mkstemp()
fh=open(fname,'w')
b=fh.write(data)
fh.close()
Gin=nx.read_leda(fname)
assert_equal(sorted(G.nodes()),sorted(Gin.nodes()))
assert_equal(sorted(G.edges()),sorted(Gin.edges()))
os.close(fd)
os.unlink(fname)
| bsd-2-clause |
nomaro/SickBeard_Backup | lib/requests/packages/chardet2/langhebrewmodel.py | 63 | 11337 | ######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Universal charset detector code.
#
# The Initial Developer of the Original Code is
# Simon Montagu
# Portions created by the Initial Developer are Copyright (C) 2005
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
# Mark Pilgrim - port to Python
# Shy Shalom - original C code
# Shoshannah Forbes - original C code (?)
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301 USA
######################### END LICENSE BLOCK #########################
from . import constants
# 255: Control characters that usually does not exist in any text
# 254: Carriage/Return
# 253: symbol (punctuation) that does not belong to word
# 252: 0 - 9
# Windows-1255 language model
# Character Mapping Table:
win1255_CharToOrderMap = ( \
255,255,255,255,255,255,255,255,255,255,254,255,255,254,255,255, # 00
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, # 10
253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253, # 20
252,252,252,252,252,252,252,252,252,252,253,253,253,253,253,253, # 30
253, 69, 91, 79, 80, 92, 89, 97, 90, 68,111,112, 82, 73, 95, 85, # 40
78,121, 86, 71, 67,102,107, 84,114,103,115,253,253,253,253,253, # 50
253, 50, 74, 60, 61, 42, 76, 70, 64, 53,105, 93, 56, 65, 54, 49, # 60
66,110, 51, 43, 44, 63, 81, 77, 98, 75,108,253,253,253,253,253, # 70
124,202,203,204,205, 40, 58,206,207,208,209,210,211,212,213,214,
215, 83, 52, 47, 46, 72, 32, 94,216,113,217,109,218,219,220,221,
34,116,222,118,100,223,224,117,119,104,125,225,226, 87, 99,227,
106,122,123,228, 55,229,230,101,231,232,120,233, 48, 39, 57,234,
30, 59, 41, 88, 33, 37, 36, 31, 29, 35,235, 62, 28,236,126,237,
238, 38, 45,239,240,241,242,243,127,244,245,246,247,248,249,250,
9, 8, 20, 16, 3, 2, 24, 14, 22, 1, 25, 15, 4, 11, 6, 23,
12, 19, 13, 26, 18, 27, 21, 17, 7, 10, 5,251,252,128, 96,253,
)
# Model Table:
# total sequences: 100%
# first 512 sequences: 98.4004%
# first 1024 sequences: 1.5981%
# rest sequences: 0.087%
# negative sequences: 0.0015%
HebrewLangModel = ( \
0,3,3,3,3,3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,2,3,2,1,2,0,1,0,0,
3,0,3,1,0,0,1,3,2,0,1,1,2,0,2,2,2,1,1,1,1,2,1,1,1,2,0,0,2,2,0,1,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,
1,2,1,2,1,2,0,0,2,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,
1,2,1,3,1,1,0,0,2,0,0,0,1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,1,0,1,2,2,1,3,
1,2,1,1,2,2,0,0,2,2,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,2,2,2,2,3,2,
1,2,1,2,2,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,2,3,2,2,3,2,2,2,1,2,2,2,2,
1,2,1,1,2,2,0,1,2,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,0,2,2,2,2,2,
0,2,0,2,2,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,0,2,2,2,
0,2,1,2,2,2,0,0,2,1,0,0,0,0,1,0,1,0,0,0,0,0,0,2,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,3,2,1,2,3,2,2,2,
1,2,1,2,2,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,
3,3,3,3,3,3,3,3,3,2,3,3,3,2,3,3,3,3,3,3,3,3,3,3,3,3,3,1,0,2,0,2,
0,2,1,2,2,2,0,0,1,2,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,2,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,2,3,2,2,3,2,1,2,1,1,1,
0,1,1,1,1,1,3,0,1,0,0,0,0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,1,1,0,0,1,0,0,1,0,0,0,0,
0,0,1,0,0,0,0,0,2,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,
0,2,0,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,2,3,3,3,2,1,2,3,3,2,3,3,3,3,2,3,2,1,2,0,2,1,2,
0,2,0,2,2,2,0,0,1,2,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,
3,3,3,3,3,3,3,3,3,2,3,3,3,1,2,2,3,3,2,3,2,3,2,2,3,1,2,2,0,2,2,2,
0,2,1,2,2,2,0,0,1,2,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,2,3,3,2,2,2,3,3,3,3,1,3,2,2,2,
0,2,0,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,3,3,3,2,3,2,2,2,1,2,2,0,2,2,2,2,
0,2,0,2,2,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,3,3,2,3,3,3,1,3,2,3,3,2,3,3,2,2,1,2,2,2,2,2,2,
0,2,1,2,1,2,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,2,3,2,3,3,2,3,3,3,3,2,3,2,3,3,3,3,3,2,2,2,2,2,2,2,1,
0,2,0,1,2,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,3,3,3,2,1,2,3,3,3,3,3,3,3,2,3,2,3,2,1,2,3,0,2,1,2,2,
0,2,1,1,2,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,2,0,
3,3,3,3,3,3,3,3,3,2,3,3,3,3,2,1,3,1,2,2,2,1,2,3,3,1,2,1,2,2,2,2,
0,1,1,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,
3,3,3,3,3,3,3,3,3,3,0,2,3,3,3,1,3,3,3,1,2,2,2,2,1,1,2,2,2,2,2,2,
0,2,0,1,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
3,3,3,3,3,3,2,3,3,3,2,2,3,3,3,2,1,2,3,2,3,2,2,2,2,1,2,1,1,1,2,2,
0,2,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,0,1,0,0,0,0,0,
1,0,1,0,0,0,0,0,2,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3,3,3,3,3,2,3,3,2,3,1,2,2,2,2,3,2,3,1,1,2,2,1,2,2,1,1,0,2,2,2,2,
0,1,0,1,2,2,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,
3,0,0,1,1,0,1,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3,0,1,0,1,0,1,1,0,1,1,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3,0,0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,
3,2,2,1,2,2,2,2,2,2,2,1,2,2,1,2,2,1,1,1,1,1,1,1,1,2,1,1,0,3,3,3,
0,3,0,2,2,2,2,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
2,2,2,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,1,2,2,2,1,1,1,2,0,1,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,0,0,0,0,0,0,
0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,3,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,1,0,2,1,0,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
0,3,1,1,2,2,2,2,2,1,2,2,2,1,1,2,2,2,2,2,2,2,1,2,2,1,0,1,1,1,1,0,
0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3,2,1,1,1,1,2,1,1,2,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0,0,0,
0,0,2,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,0,0,
2,1,1,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,1,2,1,2,1,1,1,1,0,0,0,0,
0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,2,1,2,2,2,2,2,2,2,2,2,2,1,2,1,2,1,1,2,1,1,1,2,1,2,1,2,0,1,0,1,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,3,1,2,2,2,1,2,2,2,2,2,2,2,2,1,2,1,1,1,1,1,1,2,1,2,1,1,0,1,0,1,
0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,1,2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,
0,2,0,1,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,
3,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,1,1,1,1,1,1,1,0,1,1,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,2,0,1,1,1,0,1,0,0,0,1,1,0,1,1,0,0,0,0,0,1,1,0,0,
0,1,1,1,2,1,2,2,2,0,2,0,2,0,1,1,2,1,1,1,1,2,1,0,1,1,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,1,0,0,0,0,0,1,0,1,2,2,0,1,0,0,1,1,2,2,1,2,0,2,0,0,0,1,2,0,1,
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,2,0,2,1,2,0,2,0,0,1,1,1,1,1,1,0,1,0,0,0,1,0,0,1,
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,1,0,0,0,0,0,1,0,2,1,1,0,1,0,0,1,1,1,2,2,0,0,1,0,0,0,1,0,0,1,
1,1,2,1,0,1,1,1,0,1,0,1,1,1,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,2,2,1,
0,2,0,1,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,1,0,0,1,0,1,1,1,1,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,1,2,1,0,1,1,1,1,1,1,1,1,1,1,1,0,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,1,1,0,1,1,0,1,0,0,0,1,1,0,1,
2,0,1,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,0,1,1,2,1,1,2,0,1,0,0,0,1,1,0,1,
1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,1,1,2,0,1,0,0,0,0,2,1,1,2,0,2,0,0,0,1,1,0,1,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,2,1,1,0,1,0,0,2,2,1,2,1,1,0,1,0,0,0,1,1,0,1,
2,0,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,2,2,0,0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,1,0,1,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,2,2,0,0,0,0,2,1,1,1,0,2,1,1,0,0,0,2,1,0,1,
1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,1,1,2,0,1,0,0,1,1,0,2,1,1,0,1,0,0,0,1,1,0,1,
2,2,1,1,1,0,1,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,2,1,1,0,1,0,0,1,1,0,1,2,1,0,2,0,0,0,1,1,0,1,
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,
0,1,0,0,2,0,2,1,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,1,0,1,1,2,0,1,0,0,1,1,1,0,1,0,0,1,0,0,0,1,0,0,1,
1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,1,0,1,1,0,0,1,0,0,2,1,1,1,1,1,0,1,0,0,0,0,1,0,1,
0,1,1,1,2,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,1,2,1,0,0,0,0,0,1,1,1,1,1,0,1,0,0,0,1,1,0,0,
)
Win1255HebrewModel = { \
'charToOrderMap': win1255_CharToOrderMap,
'precedenceMatrix': HebrewLangModel,
'mTypicalPositiveRatio': 0.984004,
'keepEnglishLetter': False,
'charsetName': "windows-1255"
}
| gpl-3.0 |
googleads/googleads-python-lib | examples/ad_manager/v202011/order_service/create_orders.py | 1 | 1804 | #!/usr/bin/env python
#
# Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This code example creates new orders.
To determine which orders exist, run get_all_orders.py.
"""
import uuid
# Import appropriate modules from the client library.
from googleads import ad_manager
COMPANY_ID = 'INSERT_ADVERTISER_COMPANY_ID_HERE'
SALESPERSON_ID = 'INSERT_SALESPERSON_ID_HERE'
TRAFFICKER_ID = 'INSERT_TRAFFICKER_ID_HERE'
def main(client, company_id, salesperson_id, trafficker_id):
# Initialize appropriate service.
order_service = client.GetService('OrderService', version='v202011')
# Create order objects.
orders = []
for _ in range(5):
order = {
'name': 'Order #%s' % uuid.uuid4(),
'advertiserId': company_id,
'salespersonId': salesperson_id,
'traffickerId': trafficker_id
}
orders.append(order)
# Add orders.
orders = order_service.createOrders(orders)
# Display results.
for order in orders:
print('Order with id "%s" and name "%s" was created.'
% (order['id'], order['name']))
if __name__ == '__main__':
# Initialize client object.
ad_manager_client = ad_manager.AdManagerClient.LoadFromStorage()
main(ad_manager_client, COMPANY_ID, SALESPERSON_ID, TRAFFICKER_ID)
| apache-2.0 |
lmprice/ansible | lib/ansible/modules/cloud/rackspace/rax_keypair.py | 50 | 4737 | #!/usr/bin/python
# Copyright: Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
---
module: rax_keypair
short_description: Create a keypair for use with Rackspace Cloud Servers
description:
- Create a keypair for use with Rackspace Cloud Servers
version_added: 1.5
options:
name:
description:
- Name of keypair
required: true
public_key:
description:
- Public Key string to upload. Can be a file path or string
state:
description:
- Indicate desired state of the resource
choices:
- present
- absent
default: present
author: "Matt Martz (@sivel)"
notes:
- Keypairs cannot be manipulated, only created and deleted. To "update" a
keypair you must first delete and then recreate.
- The ability to specify a file path for the public key was added in 1.7
extends_documentation_fragment: rackspace.openstack
'''
EXAMPLES = '''
- name: Create a keypair
hosts: localhost
gather_facts: False
tasks:
- name: keypair request
local_action:
module: rax_keypair
credentials: ~/.raxpub
name: my_keypair
region: DFW
register: keypair
- name: Create local public key
local_action:
module: copy
content: "{{ keypair.keypair.public_key }}"
dest: "{{ inventory_dir }}/{{ keypair.keypair.name }}.pub"
- name: Create local private key
local_action:
module: copy
content: "{{ keypair.keypair.private_key }}"
dest: "{{ inventory_dir }}/{{ keypair.keypair.name }}"
- name: Create a keypair
hosts: localhost
gather_facts: False
tasks:
- name: keypair request
local_action:
module: rax_keypair
credentials: ~/.raxpub
name: my_keypair
public_key: "{{ lookup('file', 'authorized_keys/id_rsa.pub') }}"
region: DFW
register: keypair
'''
import os
try:
import pyrax
HAS_PYRAX = True
except ImportError:
HAS_PYRAX = False
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.rax import (rax_argument_spec,
rax_required_together,
rax_to_dict,
setup_rax_module,
)
def rax_keypair(module, name, public_key, state):
changed = False
cs = pyrax.cloudservers
if cs is None:
module.fail_json(msg='Failed to instantiate client. This '
'typically indicates an invalid region or an '
'incorrectly capitalized region name.')
keypair = {}
if state == 'present':
if public_key and os.path.isfile(public_key):
try:
f = open(public_key)
public_key = f.read()
f.close()
except Exception as e:
module.fail_json(msg='Failed to load %s' % public_key)
try:
keypair = cs.keypairs.find(name=name)
except cs.exceptions.NotFound:
try:
keypair = cs.keypairs.create(name, public_key)
changed = True
except Exception as e:
module.fail_json(msg='%s' % e.message)
except Exception as e:
module.fail_json(msg='%s' % e.message)
elif state == 'absent':
try:
keypair = cs.keypairs.find(name=name)
except:
pass
if keypair:
try:
keypair.delete()
changed = True
except Exception as e:
module.fail_json(msg='%s' % e.message)
module.exit_json(changed=changed, keypair=rax_to_dict(keypair))
def main():
argument_spec = rax_argument_spec()
argument_spec.update(
dict(
name=dict(required=True),
public_key=dict(),
state=dict(default='present', choices=['absent', 'present']),
)
)
module = AnsibleModule(
argument_spec=argument_spec,
required_together=rax_required_together(),
)
if not HAS_PYRAX:
module.fail_json(msg='pyrax is required for this module')
name = module.params.get('name')
public_key = module.params.get('public_key')
state = module.params.get('state')
setup_rax_module(module, pyrax)
rax_keypair(module, name, public_key, state)
if __name__ == '__main__':
main()
| gpl-3.0 |
riga/luigi | test/_mysqldb_test.py | 95 | 1732 | # -*- coding: utf-8 -*-
#
# Copyright 2012-2015 Spotify AB
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from helpers import unittest
import mysql.connector
from luigi.contrib.mysqldb import MySqlTarget
host = 'localhost'
port = 3306
database = 'luigi_test'
username = None
password = None
table_updates = 'table_updates'
def _create_test_database():
con = mysql.connector.connect(user=username,
password=password,
host=host,
port=port,
autocommit=True)
con.cursor().execute('CREATE DATABASE IF NOT EXISTS %s' % database)
_create_test_database()
target = MySqlTarget(host, database, username, password, '', 'update_id')
class MySqlTargetTest(unittest.TestCase):
def test_touch_and_exists(self):
drop()
self.assertFalse(target.exists(),
'Target should not exist before touching it')
target.touch()
self.assertTrue(target.exists(),
'Target should exist after touching it')
def drop():
con = target.connect(autocommit=True)
con.cursor().execute('DROP TABLE IF EXISTS %s' % table_updates)
| apache-2.0 |
yfried/ansible | lib/ansible/modules/packaging/os/rpm_key.py | 100 | 6840 | #!/usr/bin/python
# -*- coding: utf-8 -*-
# Ansible module to import third party repo keys to your rpm db
# Copyright: (c) 2013, Héctor Acosta <hector.acosta@gazzang.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'core'}
DOCUMENTATION = '''
---
module: rpm_key
author:
- Hector Acosta (@hacosta) <hector.acosta@gazzang.com>
short_description: Adds or removes a gpg key from the rpm db
description:
- Adds or removes (rpm --import) a gpg key to your rpm database.
version_added: "1.3"
options:
key:
description:
- Key that will be modified. Can be a url, a file, or a keyid if the key already exists in the database.
required: true
state:
description:
- If the key will be imported or removed from the rpm db.
default: present
choices: [ absent, present ]
validate_certs:
description:
- If C(no) and the C(key) is a url starting with https, SSL certificates will not be validated. This should only be used
on personally controlled sites using self-signed certificates.
type: bool
default: 'yes'
'''
EXAMPLES = '''
# Example action to import a key from a url
- rpm_key:
state: present
key: http://apt.sw.be/RPM-GPG-KEY.dag.txt
# Example action to import a key from a file
- rpm_key:
state: present
key: /path/to/key.gpg
# Example action to ensure a key is not present in the db
- rpm_key:
state: absent
key: DEADB33F
'''
import re
import os.path
import tempfile
# import module snippets
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.urls import fetch_url
from ansible.module_utils._text import to_native
def is_pubkey(string):
"""Verifies if string is a pubkey"""
pgp_regex = ".*?(-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----).*"
return bool(re.match(pgp_regex, to_native(string, errors='surrogate_or_strict'), re.DOTALL))
class RpmKey(object):
def __init__(self, module):
# If the key is a url, we need to check if it's present to be idempotent,
# to do that, we need to check the keyid, which we can get from the armor.
keyfile = None
should_cleanup_keyfile = False
self.module = module
self.rpm = self.module.get_bin_path('rpm', True)
state = module.params['state']
key = module.params['key']
self.gpg = self.module.get_bin_path('gpg')
if not self.gpg:
self.gpg = self.module.get_bin_path('gpg2', required=True)
if '://' in key:
keyfile = self.fetch_key(key)
keyid = self.getkeyid(keyfile)
should_cleanup_keyfile = True
elif self.is_keyid(key):
keyid = key
elif os.path.isfile(key):
keyfile = key
keyid = self.getkeyid(keyfile)
else:
self.module.fail_json(msg="Not a valid key %s" % key)
keyid = self.normalize_keyid(keyid)
if state == 'present':
if self.is_key_imported(keyid):
module.exit_json(changed=False)
else:
if not keyfile:
self.module.fail_json(msg="When importing a key, a valid file must be given")
self.import_key(keyfile)
if should_cleanup_keyfile:
self.module.cleanup(keyfile)
module.exit_json(changed=True)
else:
if self.is_key_imported(keyid):
self.drop_key(keyid)
module.exit_json(changed=True)
else:
module.exit_json(changed=False)
def fetch_key(self, url):
"""Downloads a key from url, returns a valid path to a gpg key"""
rsp, info = fetch_url(self.module, url)
if info['status'] != 200:
self.module.fail_json(msg="failed to fetch key at %s , error was: %s" % (url, info['msg']))
key = rsp.read()
if not is_pubkey(key):
self.module.fail_json(msg="Not a public key: %s" % url)
tmpfd, tmpname = tempfile.mkstemp()
self.module.add_cleanup_file(tmpname)
tmpfile = os.fdopen(tmpfd, "w+b")
tmpfile.write(key)
tmpfile.close()
return tmpname
def normalize_keyid(self, keyid):
"""Ensure a keyid doesn't have a leading 0x, has leading or trailing whitespace, and make sure is uppercase"""
ret = keyid.strip().upper()
if ret.startswith('0x'):
return ret[2:]
elif ret.startswith('0X'):
return ret[2:]
else:
return ret
def getkeyid(self, keyfile):
stdout, stderr = self.execute_command([self.gpg, '--no-tty', '--batch', '--with-colons', '--fixed-list-mode', keyfile])
for line in stdout.splitlines():
line = line.strip()
if line.startswith('pub:'):
return line.split(':')[4]
self.module.fail_json(msg="Unexpected gpg output")
def is_keyid(self, keystr):
"""Verifies if a key, as provided by the user is a keyid"""
return re.match('(0x)?[0-9a-f]{8}', keystr, flags=re.IGNORECASE)
def execute_command(self, cmd):
rc, stdout, stderr = self.module.run_command(cmd, use_unsafe_shell=True)
if rc != 0:
self.module.fail_json(msg=stderr)
return stdout, stderr
def is_key_imported(self, keyid):
cmd = self.rpm + ' -q gpg-pubkey'
rc, stdout, stderr = self.module.run_command(cmd)
if rc != 0: # No key is installed on system
return False
cmd += ' --qf "%{description}" | ' + self.gpg + ' --no-tty --batch --with-colons --fixed-list-mode -'
stdout, stderr = self.execute_command(cmd)
for line in stdout.splitlines():
if keyid in line.split(':')[4]:
return True
return False
def import_key(self, keyfile):
if not self.module.check_mode:
self.execute_command([self.rpm, '--import', keyfile])
def drop_key(self, keyid):
if not self.module.check_mode:
self.execute_command([self.rpm, '--erase', '--allmatches', "gpg-pubkey-%s" % keyid[-8:].lower()])
def main():
module = AnsibleModule(
argument_spec=dict(
state=dict(type='str', default='present', choices=['absent', 'present']),
key=dict(type='str', required=True),
validate_certs=dict(type='bool', default=True),
),
supports_check_mode=True,
)
RpmKey(module)
if __name__ == '__main__':
main()
| gpl-3.0 |
bgris/ODL_bgris | lib/python3.5/site-packages/libfuturize/fixes/fix_oldstr_wrap.py | 44 | 1214 | """
For the ``future`` package.
Adds this import line:
from past.builtins import str as oldstr
at the top and wraps any unadorned string literals 'abc' or explicit byte-string
literals b'abc' in oldstr() calls so the code has the same behaviour on Py3 as
on Py2.6/2.7.
"""
from __future__ import unicode_literals
import re
from lib2to3 import fixer_base
from lib2to3.pgen2 import token
from lib2to3.fixer_util import syms
from libfuturize.fixer_util import (future_import, touch_import_top,
wrap_in_fn_call)
_literal_re = re.compile(r"[^uUrR]?[\'\"]")
class FixOldstrWrap(fixer_base.BaseFix):
BM_compatible = True
PATTERN = "STRING"
def transform(self, node, results):
if node.type == token.STRING:
touch_import_top(u'past.types', u'oldstr', node)
if _literal_re.match(node.value):
new = node.clone()
# Strip any leading space or comments:
# TODO: check: do we really want to do this?
new.prefix = u''
new.value = u'b' + new.value
wrapped = wrap_in_fn_call("oldstr", [new], prefix=node.prefix)
return wrapped
| gpl-3.0 |
manolama/dd-agent | checks.d/hdfs_namenode.py | 11 | 8470 | # (C) Datadog, Inc. 2010-2016
# All rights reserved
# Licensed under Simplified BSD License (see LICENSE)
'''
HDFS NameNode Metrics
---------------------
hdfs.namenode.capacity_total Total disk capacity in bytes
hdfs.namenode.capacity_used Disk usage in bytes
hdfs.namenode.capacity_remaining Remaining disk space left in bytes
hdfs.namenode.total_load Total load on the file system
hdfs.namenode.fs_lock_queue_length Lock queue length
hdfs.namenode.blocks_total Total number of blocks
hdfs.namenode.max_objects Maximum number of files HDFS supports
hdfs.namenode.files_total Total number of files
hdfs.namenode.pending_replication_blocks Number of blocks pending replication
hdfs.namenode.under_replicated_blocks Number of under replicated blocks
hdfs.namenode.scheduled_replication_blocks Number of blocks scheduled for replication
hdfs.namenode.pending_deletion_blocks Number of pending deletion blocks
hdfs.namenode.num_live_data_nodes Total number of live data nodes
hdfs.namenode.num_dead_data_nodes Total number of dead data nodes
hdfs.namenode.num_decom_live_data_nodes Number of decommissioning live data nodes
hdfs.namenode.num_decom_dead_data_nodes Number of decommissioning dead data nodes
hdfs.namenode.volume_failures_total Total volume failures
hdfs.namenode.estimated_capacity_lost_total Estimated capacity lost in bytes
hdfs.namenode.num_decommissioning_data_nodes Number of decommissioning data nodes
hdfs.namenode.num_stale_data_nodes Number of stale data nodes
hdfs.namenode.num_stale_storages Number of stale storages
hdfs.namenode.missing_blocks Number of missing blocks
hdfs.namenode.corrupt_blocks Number of corrupt blocks
'''
# stdlib
from urlparse import urljoin
# 3rd party
import requests
from requests.exceptions import Timeout, HTTPError, InvalidURL, ConnectionError
from simplejson import JSONDecodeError
# Project
from checks import AgentCheck
# Service check names
JMX_SERVICE_CHECK = 'hdfs.namenode.jmx.can_connect'
# URL Paths
JMX_PATH = 'jmx'
# Namesystem state bean
HDFS_NAME_SYSTEM_STATE_BEAN = 'Hadoop:service=NameNode,name=FSNamesystemState'
# Namesystem bean
HDFS_NAME_SYSTEM_BEAN = 'Hadoop:service=NameNode,name=FSNamesystem'
# Metric types
GAUGE = 'gauge'
# HDFS metrics
HDFS_NAME_SYSTEM_STATE_METRICS = {
'CapacityTotal' : ('hdfs.namenode.capacity_total', GAUGE),
'CapacityUsed' : ('hdfs.namenode.capacity_used', GAUGE),
'CapacityRemaining' : ('hdfs.namenode.capacity_remaining', GAUGE),
'TotalLoad' : ('hdfs.namenode.total_load', GAUGE),
'FsLockQueueLength' : ('hdfs.namenode.fs_lock_queue_length', GAUGE),
'BlocksTotal' : ('hdfs.namenode.blocks_total', GAUGE),
'MaxObjects' : ('hdfs.namenode.max_objects', GAUGE),
'FilesTotal' : ('hdfs.namenode.files_total', GAUGE),
'PendingReplicationBlocks' : ('hdfs.namenode.pending_replication_blocks', GAUGE),
'UnderReplicatedBlocks' : ('hdfs.namenode.under_replicated_blocks', GAUGE),
'ScheduledReplicationBlocks' : ('hdfs.namenode.scheduled_replication_blocks', GAUGE),
'PendingDeletionBlocks' : ('hdfs.namenode.pending_deletion_blocks', GAUGE),
'NumLiveDataNodes' : ('hdfs.namenode.num_live_data_nodes', GAUGE),
'NumDeadDataNodes' : ('hdfs.namenode.num_dead_data_nodes', GAUGE),
'NumDecomLiveDataNodes' : ('hdfs.namenode.num_decom_live_data_nodes', GAUGE),
'NumDecomDeadDataNodes' : ('hdfs.namenode.num_decom_dead_data_nodes', GAUGE),
'VolumeFailuresTotal' : ('hdfs.namenode.volume_failures_total', GAUGE),
'EstimatedCapacityLostTotal' : ('hdfs.namenode.estimated_capacity_lost_total', GAUGE),
'NumDecommissioningDataNodes' : ('hdfs.namenode.num_decommissioning_data_nodes', GAUGE),
'NumStaleDataNodes' : ('hdfs.namenode.num_stale_data_nodes', GAUGE),
'NumStaleStorages' : ('hdfs.namenode.num_stale_storages', GAUGE),
}
HDFS_NAME_SYSTEM_METRICS = {
'MissingBlocks' : ('hdfs.namenode.missing_blocks', GAUGE),
'CorruptBlocks' : ('hdfs.namenode.corrupt_blocks', GAUGE)
}
class HDFSNameNode(AgentCheck):
def check(self, instance):
jmx_address = instance.get('hdfs_namenode_jmx_uri')
if jmx_address is None:
raise Exception('The JMX URL must be specified in the instance configuration')
# Get metrics from JMX
self._hdfs_namenode_metrics(jmx_address,
HDFS_NAME_SYSTEM_STATE_BEAN,
HDFS_NAME_SYSTEM_STATE_METRICS)
self._hdfs_namenode_metrics(jmx_address,
HDFS_NAME_SYSTEM_BEAN,
HDFS_NAME_SYSTEM_METRICS)
self.service_check(JMX_SERVICE_CHECK,
AgentCheck.OK,
tags=['namenode_url:' + jmx_address],
message='Connection to %s was successful' % jmx_address)
def _hdfs_namenode_metrics(self, jmx_uri, bean_name, metrics):
'''
Get HDFS namenode metrics from JMX
'''
response = self._rest_request_to_json(jmx_uri,
JMX_PATH,
query_params={'qry':bean_name})
beans = response.get('beans', [])
tags = ['namenode_url:' + jmx_uri]
if beans:
bean = next(iter(beans))
bean_name = bean.get('name')
if bean_name != bean_name:
raise Exception("Unexpected bean name {0}".format(bean_name))
for metric, (metric_name, metric_type) in metrics.iteritems():
metric_value = bean.get(metric)
if metric_value is not None:
self._set_metric(metric_name, metric_type, metric_value, tags)
if 'CapacityUsed' in bean and 'CapacityTotal' in bean:
self._set_metric('hdfs.namenode.capacity_in_use', GAUGE,
float(bean['CapacityUsed']) / float(bean['CapacityTotal']), tags)
def _set_metric(self, metric_name, metric_type, value, tags=None):
'''
Set a metric
'''
if metric_type == GAUGE:
self.gauge(metric_name, value, tags=tags)
else:
self.log.error('Metric type "%s" unknown' % (metric_type))
def _rest_request_to_json(self, address, object_path, query_params):
'''
Query the given URL and return the JSON response
'''
response_json = None
service_check_tags = ['namenode_url:' + address]
url = address
if object_path:
url = self._join_url_dir(url, object_path)
# Add query_params as arguments
if query_params:
query = '&'.join(['{0}={1}'.format(key, value) for key, value in query_params.iteritems()])
url = urljoin(url, '?' + query)
self.log.debug('Attempting to connect to "%s"' % url)
try:
response = requests.get(url, timeout=self.default_integration_http_timeout)
response.raise_for_status()
response_json = response.json()
except Timeout as e:
self.service_check(JMX_SERVICE_CHECK,
AgentCheck.CRITICAL,
tags=service_check_tags,
message="Request timeout: {0}, {1}".format(url, e))
raise
except (HTTPError,
InvalidURL,
ConnectionError) as e:
self.service_check(JMX_SERVICE_CHECK,
AgentCheck.CRITICAL,
tags=service_check_tags,
message="Request failed: {0}, {1}".format(url, e))
raise
except JSONDecodeError as e:
self.service_check(JMX_SERVICE_CHECK,
AgentCheck.CRITICAL,
tags=service_check_tags,
message='JSON Parse failed: {0}, {1}'.format(url, e))
raise
except ValueError as e:
self.service_check(JMX_SERVICE_CHECK,
AgentCheck.CRITICAL,
tags=service_check_tags,
message=str(e))
raise
return response_json
def _join_url_dir(self, url, *args):
'''
Join a URL with multiple directories
'''
for path in args:
url = url.rstrip('/') + '/'
url = urljoin(url, path.lstrip('/'))
return url
| bsd-3-clause |
joone/chromium-crosswalk | third_party/jinja2/constants.py | 1169 | 1626 | # -*- coding: utf-8 -*-
"""
jinja.constants
~~~~~~~~~~~~~~~
Various constants.
:copyright: (c) 2010 by the Jinja Team.
:license: BSD, see LICENSE for more details.
"""
#: list of lorem ipsum words used by the lipsum() helper function
LOREM_IPSUM_WORDS = u'''\
a ac accumsan ad adipiscing aenean aliquam aliquet amet ante aptent arcu at
auctor augue bibendum blandit class commodo condimentum congue consectetuer
consequat conubia convallis cras cubilia cum curabitur curae cursus dapibus
diam dictum dictumst dignissim dis dolor donec dui duis egestas eget eleifend
elementum elit enim erat eros est et etiam eu euismod facilisi facilisis fames
faucibus felis fermentum feugiat fringilla fusce gravida habitant habitasse hac
hendrerit hymenaeos iaculis id imperdiet in inceptos integer interdum ipsum
justo lacinia lacus laoreet lectus leo libero ligula litora lobortis lorem
luctus maecenas magna magnis malesuada massa mattis mauris metus mi molestie
mollis montes morbi mus nam nascetur natoque nec neque netus nibh nisi nisl non
nonummy nostra nulla nullam nunc odio orci ornare parturient pede pellentesque
penatibus per pharetra phasellus placerat platea porta porttitor posuere
potenti praesent pretium primis proin pulvinar purus quam quis quisque rhoncus
ridiculus risus rutrum sagittis sapien scelerisque sed sem semper senectus sit
sociis sociosqu sodales sollicitudin suscipit suspendisse taciti tellus tempor
tempus tincidunt torquent tortor tristique turpis ullamcorper ultrices
ultricies urna ut varius vehicula vel velit venenatis vestibulum vitae vivamus
viverra volutpat vulputate'''
| bsd-3-clause |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.