def __init__(self,
prefix: str = 'RAScore',
model: str = 'ChEMBL',
n_jobs: int = 1,
**kwargs):
"""
:param prefix: Prefix to identify scoring function instance
:param model: Either 'ChEMBL', 'GDB', 'GDBMedChem' or specify a file path to a custom model
:param n_jobs: Number of python.multiprocessing jobs for multiprocessing of fps
:param kwargs:
"""
self.prefix = prefix
self.n_jobs = n_jobs
if model == 'ChEMBL':
with resources.open_binary(
'molscore.data.models.RAScore.XGB_chembl_ecfp_counts',
'model.pkl') as f:
self.model = pkl.load(f)
elif model == 'GDB':
with resources.open_binary(
'molscore.data.models.RAScore.XGB_gdbchembl_ecfp_counts',
'model.pkl') as f:
self.model = pkl.load(f)
elif model == 'GDBMedChem':
with resources.open_binary(
'molscore.data.models.RAScore.XGB_gdbmedechem_ecfp_counts',
'model.pkl') as f:
self.model = pkl.load(f)
else:
with open(os.path.abspath(model), 'rb') as f:
self.model = pkl.load(f)
def __init__(self,
image_path,
is_train=True,
inp_res=256,
out_res=64,
sigma=1,
scale_factor=0.25,
rot_factor=30,
label_type='Gaussian'):
self.img_folder = image_path # root image folders
self.is_train = is_train # training set or test set
self.inp_res = inp_res
self.out_res = out_res
self.sigma = sigma
self.scale_factor = scale_factor
self.rot_factor = rot_factor
self.label_type = label_type
# create train/val split
with gzip.open(
open_binary(stacked_hourglass.res,
'mpii_annotations.json.gz')) as f:
self.anno = json.load(f)
self.train_list, self.valid_list = [], []
for idx, val in enumerate(self.anno):
if val['isValidation'] == True:
self.valid_list.append(idx)
else:
self.train_list.append(idx)
def test_hmmer_prof():
buffer = pkg_resources.open_binary(hmmer_reader.data, "three-profs.hmm.gz")
content = gzip.decompress(buffer.read()).decode()
hmmfile = open_hmmer(StringIO(content))
hmm = hmmfile.read_model()
assert hmm.header == "HMMER3/f [3.1b2 | February 2015]"
assert dict(hmm.metadata)["LENG"] == "40"
assert hmm.M == 40
assert hmm.alphabet == "ACDEFGHIKLMNPQRSTVWY"
assert abs(hmm.match(2)["V"] - -2.72416) < 1e-6
assert abs(hmm.insert(2)["V"] - -2.98518) < 1e-6
assert abs(hmm.trans(3)["DD"] - -0.9551) < 1e-6
assert abs(hmm.compo["N"] - -3.18565) < 1e-6
output = str(hmm)
assert "SM hmmsearch -Z 45638612 -E 1000 --cpu 4 HMM pfamseq" in output
hmm = hmmfile.read_model()
assert dict(hmm.metadata)["LENG"] == "235"
hmm = hmmfile.read_model()
assert dict(hmm.metadata)["LENG"] == "449"
buffer.close()
def test_hmmer_reader_fetch_metadata2(tmp_path: Path):
buffer = pkg_resources.open_binary(hmmer_reader.data, "three-profs.hmm.gz")
content = gzip.decompress(buffer.read()).decode()
os.chdir(tmp_path)
with open("db.hmm", "w") as file:
file.write(content)
df = fetch_metadata(tmp_path / "db.hmm")
assert df.shape == (3, 4)
assert df["NAME"].values[0] == "1-cysPrx_C"
assert df["ACC"].values[0] == "PF10417.9"
assert df["LENG"].values[0] == 40
assert df["ALPH"].values[0] == "amino"
assert df["NAME"].values[1] == "120_Rick_ant"
assert df["ACC"].values[1] == "PF12574.8"
assert df["LENG"].values[1] == 235
assert df["ALPH"].values[1] == "amino"
assert df["NAME"].values[2] == "12TM_1"
assert df["ACC"].values[2] == "PF09847.9"
assert df["LENG"].values[2] == 449
assert df["ALPH"].values[2] == "amino"
assert df["NAME"].dtype is dtype("O")
assert df["ACC"].dtype is dtype("O")
assert df["LENG"].dtype is dtype("int32")
assert df["ALPH"].dtype is dtype("O")
assert tuple(df.columns) == ("NAME", "ACC", "LENG", "ALPH")
def evaluate_mpii_validation_accuracy(preds):
threshold = 0.5
SC_BIAS = 0.6
dict = loadmat(open_binary(stacked_hourglass.res, 'detections_our_format.mat'))
jnt_missing = dict['jnt_missing']
pos_gt_src = dict['pos_gt_src']
headboxes_src = dict['headboxes_src']
preds = np.array(preds)
assert preds.shape == (pos_gt_src.shape[2], pos_gt_src.shape[0], pos_gt_src.shape[1])
pos_pred_src = np.transpose(preds, [1, 2, 0])
jnt_visible = 1 - jnt_missing
uv_error = pos_pred_src - pos_gt_src
uv_err = np.linalg.norm(uv_error, axis=1)
headsizes = headboxes_src[1, :, :] - headboxes_src[0, :, :]
headsizes = np.linalg.norm(headsizes, axis=0)
headsizes *= SC_BIAS
scale = np.multiply(headsizes, np.ones((len(uv_err), 1)))
scaled_uv_err = np.divide(uv_err, scale)
scaled_uv_err = np.multiply(scaled_uv_err, jnt_visible)
jnt_count = np.sum(jnt_visible, axis=1)
less_than_threshold = np.multiply((scaled_uv_err < threshold), jnt_visible)
PCKh = np.divide(100. * np.sum(less_than_threshold, axis=1), jnt_count)
PCKh = np.ma.array(PCKh, mask=False)
PCKh.mask[6:8] = True
return PCKh
def open_binary(self, *args):
bin_fd = open_binary(*args)
if self.in_memory:
mem_bin_fd = BytesIO(bin_fd.read())
mem_bin_fd.seek(0)
bin_fd.close()
return mem_bin_fd
else:
return bin_fd
def open_binary(self, *args):
bin_fd = open_binary(*args)
if self.in_memory:
mem_bin_fd = BytesIO(bin_fd.read())
mem_bin_fd.seek(0)
bin_fd.close()
return mem_bin_fd
else:
return bin_fd
def test_hmmer_reader_fetch_metadata_corrupted3(tmp_path: Path):
buffer = pkg_resources.open_binary(hmmer_reader.data, "corrupted3.hmm.gz")
content = gzip.decompress(buffer.read()).decode()
os.chdir(tmp_path)
with open("db.hmm", "w") as file:
file.write(content)
with pytest.raises(ParsingError):
fetch_metadata(tmp_path / "db.hmm")
def setUp(self):
with open_binary('tests.data', 'example02_image.jpg') as f:
self.image: PIL.Image.Image = PIL.Image.open(f).copy()
with open_text('tests.data', 'example02_camera.json') as f:
camera_params = json.load(f)
self.camera = CameraIntrinsics(
torch.tensor(camera_params['intrinsic'])[:3])
with open_text('tests.data', 'example02_univ_annot3.txt') as f:
self.points = torch.as_tensor(np.loadtxt(f))
def open_resource_binary(*path):
"""Return a file-like object opened for binary reading of the resource.
If the resource does not already exist on its own on the file system,
a temporary file will be created. If the file was created, it
will be deleted upon exiting the context manager (no exception is
raised if the directory was deleted prior to the context manager
exiting).
"""
if len(path) == 0:
raise TypeError("must provide a path")
file_name = path[-1]
package = ".".join([RESOURCE_MODULE] + list(path[:-1]))
return importlib_resources.open_binary(package, file_name)
def initialize_audio(self):
snd = wave.open(open_binary('ursim.sounds', 'beep.wav'))
params = snd.getparams()
assert params.sampwidth == 2
sdata = numpy.empty((params.nframes, params.nchannels),
dtype=numpy.int16)
bytes_per_frame = params.nchannels * params.sampwidth
blocksize = 1024
cur_frame = 0
while True:
block_bytes = snd.readframes(blocksize)
block_array = numpy.frombuffer(block_bytes, dtype=sdata.dtype)
block_array = block_array.reshape(-1, params.nchannels)
frames_read = len(block_array)
sdata[cur_frame:cur_frame+frames_read] = block_array
cur_frame += frames_read
if frames_read < blocksize:
break
assert cur_frame == params.nframes
self.snd_should_play = False
self.snd_playback_frame = 0
self.snd_data = sdata
try:
self.stream = sounddevice.OutputStream(samplerate=params.framerate,
channels=params.nchannels,
dtype='int16',
blocksize=1024,
callback=self.snd_callback)
self.stream.start()
except:
self.stream = None
def tmp_path_with_ui_fixture(
tmp_path_factory: pytest.TempPathFactory) -> pathlib.Path:
directory_path = tmp_path_factory.mktemp(
basename="tmp_path_with_ui_fixture", numbered=True)
name = "example.ui"
ui_source_file = importlib_resources.open_binary(package=ssst._tests,
resource=name)
ui_target_path = directory_path.joinpath(name)
with ui_target_path.open("wb") as ui_target_file:
shutil.copyfileobj(ui_source_file, ui_target_file)
return directory_path
def test_cli_out_of_range():
buffer = pkg_resources.open_binary(hmmer_reader.data, "PF02545.hmm.gz")
text = gzip.decompress(buffer.read()).decode()
runner = CliRunner()
with runner.isolated_filesystem():
def invoke(cmd):
return runner.invoke(hmmer_reader.cli, cmd)
with open("PF02545.hmm", "w") as f:
f.write(text)
r = invoke(["PF02545.hmm", "--match", "167"])
assert r.exit_code == 1
def load_ui(widget, package, filename):
"""
Initialize widget from ``.uic`` file loaded from the given package.
This function is for loading GUIs that were developed using the qt-designer
rapid development tool which creates ``.uic`` description files. These can
be saved in the same package alongside the corresponding python code. Now,
in the class that implements the widget, use this function as follows::
class MyWidget(QWidget):
def __init__(self):
super().__init__()
load_ui(self, __package__, 'mywidget.uic')
"""
with open_binary(package, filename) as f:
uic.loadUi(f, widget)
def load_ui(widget, package, filename):
"""
Initialize widget from ``.uic`` file loaded from the given package.
This function is for loading GUIs that were developed using the qt-designer
rapid development tool which creates ``.uic`` description files. These can
be saved in the same package alongside the corresponding python code. Now,
in the class that implements the widget, use this function as follows::
class MyWidget(QWidget):
def __init__(self):
super().__init__()
load_ui(self, __package__, 'mywidget.uic')
"""
with open_binary(package, filename) as f:
uic.loadUi(f, widget)
def test_utf7_message_with_inline_ascii_sig(self):
# The test message is bigger than 1K. Set the threshold bigger to
# avoid double processing in make_digest_messages.
self._mlist.digest_size_threshold = 5
# Subscribe some users receiving digests.
anne = subscribe(self._mlist, 'Anne')
anne.preferences.delivery_mode = DeliveryMode.mime_digests
bart = subscribe(self._mlist, 'Bart')
bart.preferences.delivery_mode = DeliveryMode.plaintext_digests
with open_binary('mailman.runners.tests.data',
'ascii_in_utf7.eml') as fp:
msg = message_from_binary_file(fp, Message)
# Use any error logs as the error message if the test fails.
error_log = LogFileMark('mailman.error')
make_digest_messages(self._mlist, msg)
# The runner will send the file to the shunt queue on exception.
self.assertEqual(len(self._shuntq.files), 0, error_log.read())
self._check_virgin_queue()
def configure_run(scanner, plate_type, plates, orientation, parse_dates):
config = dict()
config["parse_dates"] = parse_dates
if parse_dates:
config["index_name"] = "time"
else:
config["index_name"] = "source"
if plates is None:
config["plate_names"] = PLATES[scanner]
else:
allowed = frozenset(PLATES[scanner])
for p in plates:
if p not in allowed:
raise ValueError(
"Specified tray '{}' does not exist or only on the other "
"scanner.".format(p))
config["plate_names"] = plates
plate_index = {p: i for i, p in enumerate(PLATES[scanner])}
config["plate_indexes"] = [plate_index[p] for p in config["plate_names"]]
with open_binary(gp_align.data, "plate_specs.json") as file_handle:
plate_specs = json.load(file_handle)
rows, columns = plate_specs["rows_and_columns"][str(plate_type)]
config["rows"] = rows
config["columns"] = columns
LOGGER.debug("Plate type %d has %d rows and %d columns.", plate_type,
rows, columns)
calibration_name_left = "calibration_type_{:d}_left".format(plate_type)
with path(gp_align.data, calibration_name_left + ".png") as file_path:
config["left_image"] = detect_edges(file_path)
calibration_name_right = "calibration_type_{:d}_right".format(plate_type)
with path(gp_align.data, calibration_name_right + ".png") as file_path:
config["right_image"] = detect_edges(file_path)
config["well_names"] = well_names(rows, columns, orientation)
config["plate_size"] = plate_specs["plate_size"]
config["left_positions"] = plate_specs[
"plate_positions"][calibration_name_left]
config["right_positions"] = plate_specs[
"plate_positions"][calibration_name_right]
return config
def configure_run(scanner, plate_type, plates, orientation, parse_dates):
config = dict()
config["parse_dates"] = parse_dates
if parse_dates:
config["index_name"] = "time"
else:
config["index_name"] = "source"
if plates is None:
config["plate_names"] = PLATES[scanner]
else:
allowed = frozenset(PLATES[scanner])
for p in plates:
if p not in allowed:
raise ValueError(
"Specified tray '{}' does not exist or only on the other "
"scanner.".format(p))
config["plate_names"] = plates
plate_index = {p: i for i, p in enumerate(PLATES[scanner])}
config["plate_indexes"] = [plate_index[p] for p in config["plate_names"]]
with open_binary(gp_align.data, "plate_specs.json") as file_handle:
plate_specs = json.load(file_handle)
rows, columns = plate_specs["rows_and_columns"][str(plate_type)]
config["rows"] = rows
config["columns"] = columns
LOGGER.debug("Plate type %d has %d rows and %d columns.", plate_type, rows,
columns)
calibration_name_left = "calibration_type_{:d}_left".format(plate_type)
with path(gp_align.data, calibration_name_left + ".png") as file_path:
config["left_image"] = detect_edges(file_path)
calibration_name_right = "calibration_type_{:d}_right".format(plate_type)
with path(gp_align.data, calibration_name_right + ".png") as file_path:
config["right_image"] = detect_edges(file_path)
config["well_names"] = well_names(rows, columns, orientation)
config["plate_size"] = plate_specs["plate_size"]
config["left_positions"] = plate_specs["plate_positions"][
calibration_name_left]
config["right_positions"] = plate_specs["plate_positions"][
calibration_name_right]
return config
def __init__(self):
super().__init__()
self.create_window('Hello World', 800, 600)
gl.Enable(gl.CULL_FACE)
gl.Enable(gl.FRAMEBUFFER_SRGB)
self.framebuffer = gfx.Framebuffer(512, 512)
self.texture = gfx.load_texture(
open_binary('ursim.textures', 'monalisa.jpg'), 'RGB')
self.fsquad = gfx.FullscreenQuad(self.texture)
ballpos = gfx.translation_matrix(gfx.vec3(1.5, 0, 0))
cylpos = gfx.translation_matrix(gfx.vec3(0, 1.5, 0))
self.objects = [
gfx.IndexedPrimitives.box(gfx.vec3(1, 1, 1),
gfx.vec3(0.5, 0.75, 1.0),
texture=None),
gfx.IndexedPrimitives.sphere(0.5,
32,
24,
gfx.vec3(1, 0, 0),
model_pose=ballpos),
gfx.IndexedPrimitives.cylinder(0.5,
1,
32,
1,
gfx.vec3(1, 0, 1),
model_pose=cylpos)
]
self.box = self.objects[0]
self.mouse_pos = numpy.array(self.framebuffer_size / 2,
dtype=numpy.float32)
self.handle_mouse_rot()
def test_hmmer_reader():
buffer = pkg_resources.open_binary(hmmer_reader.data, "PF02545.hmm.gz")
content = gzip.decompress(buffer.read()).decode()
hmmfile = open_hmmer(StringIO(content))
hmm = hmmfile.read_model()
assert hmm.header == "HMMER3/f [3.1b2 | February 2015]"
assert dict(hmm.metadata)["LENG"] == "166"
assert hmm.M == 166
assert hmm.alphabet == "ACDEFGHIKLMNPQRSTVWY"
assert abs(hmm.match(2)["V"] - -2.0152) < 1e-6
assert abs(hmm.insert(2)["V"] - -2.98518) < 1e-6
assert abs(hmm.trans(83)["DD"] - -0.94424) < 1e-6
assert abs(hmm.compo["N"] + 3.21795) < 1e-6
output = str(hmm)
assert "SM hmmsearch -Z 45638612 -E 1000 --cpu 4 HMM pfamseq" in output
buffer.close()
def test_hmmer_reader_nt():
buffer = pkg_resources.open_binary(hmmer_reader.data,
"2OG-FeII_Oxy_3-nt.hmm.gz")
content = gzip.decompress(buffer.read()).decode()
hmmfile = open_hmmer(StringIO(content))
hmm = hmmfile.read_model()
assert hmm.header == "HMMER3/f [3.1b2 | February 2015]"
assert dict(hmm.metadata)["LENG"] == "315"
assert hmm.M == 315
assert hmm.alphabet == "ACGT"
assert abs(hmm.match(2)["A"] - -2.35771) < 1e-6
assert abs(hmm.insert(2)["G"] - -1.38629) < 1e-6
assert abs(hmm.trans(83)["DD"] - -0.40547) < 1e-6
assert abs(hmm.compo["T"] - -1.50794) < 1e-6
output = str(hmm)
assert "DATE Sun May 24 19:35:19 2015" in output
buffer.close()
def test_hmmer_reader_fetch_metadata1(tmp_path: Path):
buffer = pkg_resources.open_binary(hmmer_reader.data, "PF02545.hmm.gz")
content = gzip.decompress(buffer.read()).decode()
os.chdir(tmp_path)
with open("db.hmm", "w") as file:
file.write(content)
df = fetch_metadata(tmp_path / "db.hmm")
assert df.shape == (1, 4)
assert df["NAME"].values[0] == "Maf"
assert df["ACC"].values[0] == "PF02545.14"
assert df["LENG"].values[0] == 166
assert df["ALPH"].values[0] == "amino"
assert df["NAME"].dtype is dtype("O")
assert df["ACC"].dtype is dtype("O")
assert df["LENG"].dtype is dtype("int32")
assert df["ALPH"].dtype is dtype("O")
assert tuple(df.columns) == ("NAME", "ACC", "LENG", "ALPH")
def __init__(self,
image_path,
is_train=True,
inp_res=256,
sigma=1,
scale_factor=0.25,
rot_factor=30,
label_type='Gaussian'):
self.img_folder = image_path # root image folders
self.is_train = is_train # training set or test set
if not isinstance(inp_res,
(list, tuple)): # Input res stored as (H, W)
self.inp_res = [inp_res, inp_res]
else:
self.inp_res = inp_res
self.out_res = [
int(self.inp_res[0] / self.INPUT_OUTPUT_RATIO),
int(self.inp_res[1] / self.INPUT_OUTPUT_RATIO)
]
self.sigma = sigma
self.scale_factor = scale_factor
self.rot_factor = rot_factor
self.label_type = label_type
# create train/val split
with gzip.open(
open_binary(stacked_hourglass.res,
'mpii_annotations.json.gz')) as f:
self.anno = json.load(f)
self.train_list, self.valid_list = [], []
for idx, val in enumerate(self.anno):
if val['isValidation'] == True:
self.valid_list.append(idx)
else:
self.train_list.append(idx)
def execute(self, package, path):
with resources.open_binary(package, path):
pass
def open(self):
return pkg_resources.open_binary(self.module, str(self.rel_path))
def dockerfile(file, binary=True):
if binary:
return pkg_resources.open_binary(dockerfiles, file)
else:
return pkg_resources.open_text(dockerfiles, file)
def script(file, binary=True):
if binary:
return pkg_resources.open_binary(sh, file)
else:
return pkg_resources.open_text(sh, file)
def test_cli_frame():
buffer = pkg_resources.open_binary(hmmer_reader.data, "PF02545.hmm.gz")
text = gzip.decompress(buffer.read()).decode()
runner = CliRunner()
with runner.isolated_filesystem():
def invoke(cmd):
return runner.invoke(hmmer_reader.cli, cmd)
with open("PF02545.hmm", "w") as f:
f.write(text)
r = invoke(["PF02545.hmm"])
assert "STATS LOCAL MSV -9.9559 0.70785" in r.stdout
r = invoke(["PF02545.hmm", "--alphabet"])
assert r.stdout.strip() == "ACDEFGHIKLMNPQRSTVWY"
r = invoke(["PF02545.hmm", "--length"])
assert r.stdout.strip() == "166"
r = invoke(["PF02545.hmm", "--match", "0"])
tbl = parse_table(r.stdout)
assert tbl["A"] == 1.0
assert tbl["C"] == 0.0
r = invoke(["PF02545.hmm", "--match", "0"])
tbl = parse_table(r.stdout)
assert tbl["A"] == 1.0
assert tbl["C"] == 0.0
r = invoke(["PF02545.hmm", "--match", "1"])
tbl = parse_table(r.stdout)
assert abs(tbl["A"] - 0.063306327140559060) < 1e-7
assert abs(tbl["C"] - 0.004970275538839500) < 1e-7
r = invoke(["PF02545.hmm", "--match", "0", "--log"])
tbl = parse_table(r.stdout)
assert tbl["A"] == 0.0
assert isinf(tbl["C"])
r = invoke(["PF02545.hmm", "--match", "1", "--log"])
tbl = parse_table(r.stdout)
assert abs(tbl["A"] - log(0.063306327140559060)) < 1e-7
assert abs(tbl["C"] - log(0.004970275538839500)) < 1e-7
r = invoke(["PF02545.hmm", "--insert", "166"])
tbl = parse_table(r.stdout)
assert abs(tbl["M"] - 0.014308521644640306) < 1e-7
assert abs(tbl["Y"] - 0.026916117721584094) < 1e-7
r = invoke(["PF02545.hmm", "--insert", "166", "--log"])
tbl = parse_table(r.stdout)
assert abs(tbl["M"] - log(0.014308521644640306)) < 1e-7
assert abs(tbl["Y"] - log(0.026916117721584094)) < 1e-7
r = invoke(["PF02545.hmm", "--match", "5", "--sort"])
assert "A 0.6014030" in r.stdout.strip().splitlines()[0].strip()
assert "G 0.1542099" in r.stdout.strip().splitlines()[1].strip()
def test_open_binary(self):
with resources.open_binary(self.data, 'utf-8.file') as fp:
result = fp.read()
self.assertEqual(result, b'Hello, UTF-8 world!\n')
def __init__(self):
# open all the files in binary reading mode
# for more info on what is stored in which .bin file, please read the comments in file_converter.py
self.poly_zone_ids = open_binary('timezonefinder', 'poly_zone_ids.bin')
self.poly_coord_amount = open_binary('timezonefinder', 'poly_coord_amount.bin')
self.poly_adr2data = open_binary('timezonefinder', 'poly_adr2data.bin')
self.poly_data = open_binary('timezonefinder', 'poly_data.bin')
self.poly_max_values = open_binary('timezonefinder', 'poly_max_values.bin')
self.poly_nr2zone_id = open_binary('timezonefinder', 'poly_nr2zone_id.bin')
self.hole_poly_ids = open_binary('timezonefinder', 'hole_poly_ids.bin')
self.hole_coord_amount = open_binary('timezonefinder', 'hole_coord_amount.bin')
self.hole_adr2data = open_binary('timezonefinder', 'hole_adr2data.bin')
self.hole_data = open_binary('timezonefinder', 'hole_data.bin')
self.shortcuts_entry_amount = open_binary('timezonefinder', 'shortcuts_entry_amount.bin')
self.shortcuts_adr2data = open_binary('timezonefinder', 'shortcuts_adr2data.bin')
self.shortcuts_data = open_binary('timezonefinder', 'shortcuts_data.bin')
self.shortcuts_unique_id = open_binary('timezonefinder', 'shortcuts_unique_id.bin')
# store for which polygons (how many) holes exits and the id of the first of those holes
# since there are very few (+-22) it is feasible to keep them in the memory
self.hole_registry = {}
# read the polygon ids for all the holes
for i, block in enumerate(iter(lambda: self.hole_poly_ids.read(2), b'')):
poly_id = unpack(b'<H', block)[0]
try:
amount_of_holes, hole_id = self.hole_registry[poly_id]
self.hole_registry.update({
poly_id: (amount_of_holes + 1, hole_id),
})
except KeyError:
self.hole_registry.update({
poly_id: (1, i),
})
def __call__(self, language_code=None):
if language_code in ('en', None):
return NullTranslations()
mo_file = 'mailman-%s.mo' % language_code
with open_binary('mailman.testing', mo_file) as fp:
return GNUTranslations(fp)
