def format_loan_table(loans: List[Loan], include_id=False):
"""Format the given list of loans into a markdown table.
Arguments:
loans (list[Loan]): The list of loans to format into a table.
include_id (bool): True if the id of the loan should be included in
the table, false otherwise
Returns:
(str) The markdown formatted table
"""
tus.check(loans=(loans, (tuple, list)), include_id=(include_id, bool))
tus.check_listlike(loans=(loans, Loan))
result_lines = [
'Lender|Borrower|Amount Given|Amount Repaid|Unpaid?|Original Thread'
+ '|Date Given|Date Paid Back' + ('|id' if include_id else ''),
':--|:--|:--|:--|:--|:--|:--|:--' + ('|:--' if include_id else '')
]
line_fmt = '|'.join('{' + a + '}' for a in (
'lender', 'borrower', 'principal', 'principal_repayment',
'unpaid_bool', 'permalink', 'created_at_pretty', 'repaid_at_pretty',
*(['id'] if include_id else [])
))
for loan in loans:
loan_dict = loan.dict().copy()
loan_dict['permalink'] = loan_dict.get('permalink', '')
loan_dict['unpaid_bool'] = '***UNPAID***' if loan.unpaid_at is not None else ''
loan_dict['created_at_pretty'] = loan.created_at.strftime('%b %d, %Y')
loan_dict['repaid_at_pretty'] = (
loan.repaid_at.strftime('%b %d, %Y') if loan.repaid_at is not None else ''
)
result_lines.append(line_fmt.format(**loan_dict))
return '\n'.join(result_lines)
def __init__(self,
trajectory: ProjectedTrajectory,
default_styling: typing.Tuple[typing.Tuple[np.ndarray, dict]],
title: str = 'Projected Trajectory',
zoom: np.ndarray = None,
rotation: typing.Tuple[float, float] = (30, 45),
visible_points: typing.Tuple[typing.Tuple[np.ndarray,
np.ndarray,
dict]] = None):
if visible_points is None:
visible_points = ((trajectory.snapshots[0].projected_samples,
np.ones(trajectory.num_samples,
dtype='bool'), dict()), )
if zoom is None:
zoom = get_square_bounds_for_all(pts for (pts, mask,
d) in visible_points)
tus.check(trajectory=(trajectory, ProjectedTrajectory),
default_styling=(default_styling, (list, tuple)),
title=(title, str),
rotation=(rotation, (list, tuple)),
visible_points=(visible_points, (list, tuple)))
tus.check_ndarrays(zoom=(zoom, (3, 2), ('float32', 'float64')))
tus.check_listlike(rotation=(rotation, (int, float), 2))
self.trajectory = trajectory
self.default_styling = default_styling
self.title = title
self.zoom = zoom
self.rotation = rotation
self.visible_points = visible_points
def reshape(self, shape: typing.Tuple[int]) -> 'FluentModule':
"""Reshapes the data to the specified shape. Must correspond to the
same total number of features.
.. note::
The batch dimension is preserved.
:param shape: the new shape for the data
:type shape: tuple[int]
:returns: self
:rtype: FluentModule
"""
tus.check(shape=(shape, (list, tuple)))
tus.check_listlike(shape=(shape, int, (1, None)))
for features in shape:
if features <= 0:
raise ValueError(f'shape={shape} must be positive')
old_num_features = reduce(operator.mul, self.shape)
new_num_features = reduce(operator.mul, shape)
if old_num_features != new_num_features:
raise ValueError(
f'cannot view {self.shape} as {shape}: expected ' +
f'{old_num_features} but got {new_num_features}')
self.sequence.append(self._wrap(Reshape(*shape)))
self.shape = tuple(shape)
if self.is_verbose:
print(f' Reshape -> {self.shape}')
return self
def overlay(self, overlay: FrameGenerator, pos: typing.Tuple[int, int]):
"""Overlays the current frame generator with the given one at the given
position. Note that the overlayed frame generator must have the same
duration as the current one and must fit entirely within the frame
"""
tus.check(overlay=(overlay, FrameGenerator), pos=(pos, (list, tuple)))
tus.check_listlike(pos=(pos, int, 2))
return self.apply(OverlayFrameGenerator, overlay, pos)
def __init__(self,
child: FrameGenerator,
new_frame_size: typing.Tuple[int, int],
resample: int = PIL.Image.LANCZOS):
tus.check(child=(child, FrameGenerator),
new_frame_size=(new_frame_size, (list, tuple)),
resample=(resample, int))
tus.check_listlike(new_frame_size=(new_frame_size, int, 2))
self.child = child
self.new_frame_size = tuple(new_frame_size)
self.resample = resample
def __init__(self, shape: typing.Tuple[int], assume_wrapped: bool = False):
tus.check(shape=(shape, (list, tuple)),
assume_wrapped=(assume_wrapped, bool))
tus.check_listlike(shape=(shape, int, (1, None)))
for features in shape:
if features <= 0:
raise ValueError(f'shape={shape} must be positive')
self.shape = tuple(shape)
self.sequence = []
self.is_verbose = False
self.wrapped = assume_wrapped
def __init__(self, urls, weights):
tus.check(urls=(urls, (list, tuple)), weights=(weights, (list, tuple)))
tus.check_listlike(urls=(urls, str), weights=(weights, (int, float)))
self.urls = urls
self.weights = [float(w) for w in weights]
self._rolling_sum_weights = []
_sum = 0.0
for weight in self.weights:
_sum += weight
self._rolling_sum_weights.append(_sum)
def __init__(self, scenes: typing.Tuple[Scene]):
tus.check(scenes=(scenes, (list, tuple)))
tus.check_listlike(scenes=(scenes, Scene))
self.scenes = tuple(scenes)
scenes_end_at = []
cur = 0
for scene in scenes:
cur += scene.duration
scenes_end_at.append(cur)
self.scenes_end_at = tuple(scenes_end_at)
self._scene_hint = 0
self._last_scene = None
def __init__(self, snapshots: typing.List[PCTrajectoryGenSnapshot]) -> None:
tus.check_listlike(snapshots=(snapshots, PCTrajectoryGenSnapshot))
fdtype = snapshots[0].principal_vectors.dtype
num_pcs = snapshots[0].principal_values.shape[0]
for i, snap in enumerate(snapshots):
if snap.principal_vectors.dtype != fdtype:
raise ValueError(f'mismatched floating data types; for snapshots[0] is {fdtype}, '
+ f'for snapshots[{i}] is {snap.principal_vectors.dtype}')
if snap.principal_values.shape[0] != num_pcs:
raise ValueError(f'mismatched number of pcs; for snapshots[0] is {num_pcs}, '
+ f'for snapshots[{i}] is {snap.principal_values.shape[0]}')
self.snapshots = snapshots
def __init__(self, frame_size_inches: typing.Tuple[float, float],
dpi: int):
tus.check(frame_size_inches=(frame_size_inches, (list, tuple)),
dpi=(dpi, int))
tus.check_listlike(frame_size_inches=(frame_size_inches, float, 2))
self.frame_size_inches = tuple(frame_size_inches)
self.dpi = dpi
self._frame_size = (int(frame_size_inches[0] * dpi),
int(frame_size_inches[1] * dpi))
# correct for rounding
frame_size_inches = (self._frame_size[0] / dpi,
self._frame_size[1] / dpi)
def __init__(self, children: typing.Tuple[Scene],
sep_enters: bool) -> None:
tus.check(children=(children, (list, tuple)),
sep_enters=(sep_enters, bool))
tus.check_listlike(children=(children, Scene, (1, None)))
duration = children[0].duration
for i, child in enumerate(children):
if child.duration != duration:
raise ValueError(f'children[0].duration={duration}, but ' +
f'children[{i}].duration={child.duration}')
self.children = tuple(children)
self.sep_enters = sep_enters
def to_trajectory(sample_labels: torch.tensor, all_hid_acts: typing.List[torch.tensor],
num_pcs: int) -> PCTrajectoryGen:
"""Converts the given labels and hidden activations to a trajectory with the specified
number of principal components.
Args:
sample_labels (torch.tensor): The labels / targets for the corresponding samples
size: [num_samples, ...]
dtype: any
first index is which sample
all_hid_acts (list[torch.tensor]): the hidden activations through time or layers
size: [num_layers]
each element:
size: [num_samples, layer_size]
dtype: float-like
the first index is which sample
the second index is which feature
Returns:
The trajectory found by calculating the top num_pcs pcs and then projecting the samples
onto those pcs. For plotting it may be helpful to use a PCTrajectoryFFMatchInfo which works
for the Gen version as well (since it is agnostic to labels)
"""
tus.check(sample_labels=(sample_labels, torch.tensor),
all_hid_acts=(all_hid_acts, (list, tuple)),
num_pcs=(num_pcs, int))
tus.check_listlike(all_hid_acts=(all_hid_acts, torch.Tensor))
snapshots = []
for idx, hid_acts in enumerate(all_hid_acts):
torch.check_tensors(
**{f'hid_acts[{idx}]': (
hid_acts,
(
('num_samples', sample_labels.shape[0]),
('layer_size', None)
),
(torch.float, torch.double)
)}
)
pc_vals, pc_vecs = pca.get_hidden_pcs(hid_acts, num_pcs)
projected = pca.project_to_pcs(hid_acts, pc_vecs, out=None)
snapshots.append(PCTrajectoryGenSnapshot(pc_vecs, pc_vals, projected, sample_labels))
return PCTrajectoryGen(snapshots)
def __init__(self, frame_size_in: typing.Tuple[float, float], dpi: int):
tus.check(
frame_size_in=(frame_size_in, (list, tuple)),
dpi=(dpi, int)
)
tus.check_listlike(frame_size_in=(frame_size_in, (int, float), 2))
# this fixes rounding
_frame_size = (
int(round(frame_size_in[0] * dpi)),
int(round(frame_size_in[1] * dpi))
)
frame_size_in = (_frame_size[0] / dpi, _frame_size[1] / dpi)
self.frame_size_in = frame_size_in
self.dpi = dpi
self._frame_size = _frame_size
def __init__(self, anchors, tokens):
if isinstance(anchors, str):
anchors = (anchors, )
tus.check(anchors=(anchors, (list, tuple)),
tokens=(tokens, (list, tuple)))
tus.check_listlike(anchors=(anchors, str))
if not anchors:
raise ValueError('at least one anchor must be specified')
for idx, token in enumerate(tokens):
tus.check(**{f'tokens_{idx}': (token, dict)})
tus.check(
**{
f'tokens_{idx}_token': (token['token'], Token),
f'tokens_{idx}_optional': (token['optional'], bool)
})
self.anchors = anchors
self.tokens = tokens
def __init__(self, state: ActState, renderer: ActRenderer,
scenes: typing.Tuple[Scene]):
tus.check(state=(state, ActState),
renderer=(renderer, ActRenderer),
scenes=(scenes, (list, tuple)))
tus.check_listlike(scenes=(scenes, Scene))
self.state = state
self.renderer = renderer
self.scenes = tuple(scenes)
scenes_end_at = []
cur = 0
for scene in scenes:
cur += scene.duration
scenes_end_at.append(cur)
self.scenes_end_at = scenes_end_at
self._scene_hint = 0
self._last_scene = None
def __init__(self, children: typing.Tuple[FrameGenerator]):
tus.check(children=(children, (list, tuple)))
tus.check_listlike(children=(children, FrameGenerator, (1, None)))
self.children = tuple(children)
self.children_end_at = []
cur = 0
frame_size = self.children[0].frame_size
for i, child in enumerate(self.children):
if child.frame_size != frame_size:
raise ValueError(
f'children[0].frame_size = {frame_size}, but ' +
f'children[{i}].frame_size = {child.frame_size}')
cur += child.duration
self.children_end_at.append(cur)
self._search_hint = 0
def __init__(self,
cluster,
timeout_seconds,
back_off,
ttl_seconds,
auth,
verify=None,
disable_database_delete=True,
protected_databases=None,
disable_collection_delete=True,
protected_collections=None):
"""Initializes Config by setting the corresponding attributes. For
auth if it is a StatefulAuth it is wrapped with a StatefulAuthWrapper.
"""
if isinstance(auth, StatefulAuth):
auth = StatefulAuthWrapper(auth)
if protected_databases is None:
protected_databases = []
if protected_collections is None:
protected_collections = []
tus.check(cluster=(cluster, Cluster),
timeout_seconds=(timeout_seconds, int),
back_off=(back_off, BackOffStrategy),
ttl_seconds=(ttl_seconds, (int, type(None))),
auth=(auth, Auth),
verify=(verify, (str, type(None))),
disable_database_delete=(disable_database_delete, bool),
protected_databases=(protected_databases, (list, tuple)),
disable_collection_delete=(disable_collection_delete, bool),
protected_collections=(protected_collections, (list, tuple)))
tus.check_listlike(protected_databases=(protected_databases, str),
protected_collections=(protected_collections, str))
self.cluster = cluster
self.timeout_seconds = timeout_seconds
self.back_off = back_off
self.ttl_seconds = ttl_seconds
self.auth = auth
self.verify = verify
self.disable_database_delete = disable_database_delete
self.protected_databases = protected_databases
self.disable_collection_delete = disable_collection_delete
self.protected_collections = protected_collections
def __init__(self, words: typing.List[str], char_delay: int):
tus.check_listlike(words=(words, str))
tus.check(char_delay=(char_delay, (int, float)))
super().__init__(len(words), 1, 2)
self.words = words
self.char_delay = float(char_delay)
self.encoded_words = None
if PRE_ENCODE:
self.encoded_words = []
for word in self.words:
inputs = [menc.encode_input(i) for i in word]
inputs.append(menc.encode_input_stop())
outputs = [
menc.encode_output(i, self.char_delay) for i in word
]
outputs.append(menc.encode_output_stop())
self.encoded_words.append(
(Sequence(raw=inputs), Sequence(raw=outputs)))
def __init__(self,
frame_size: typing.Tuple[int, int],
dpi: typing.Union[int, float],
bitrate: int,
fps: int,
outfile: str,
max_ooo_frames: int = 5000,
block_size: int = 4048) -> None:
tus.check(frame_size=(frame_size, (list, tuple)),
dpi=(dpi, (int, float)),
bitrate=(bitrate, int),
fps=(fps, int),
outfile=(outfile, str),
max_ooo_frames=(max_ooo_frames, (int, float)),
block_size=(block_size, int))
tus.check_listlike(frame_size=(frame_size, (int, float), 2))
wo_ext, ext = os.path.splitext(outfile)
if ext == '':
outfile = wo_ext + '.mp4'
elif ext != '.mp4':
raise NotImplementedError(
f'only mp4 encoding is supported, but got {ext}')
if os.path.exists(outfile):
raise FileExistsError(outfile)
self.frame_size = frame_size
self.dpi = dpi
self.bitrate = bitrate
self.fps = fps
self.outfile = outfile
self.ffmpeg_proc = None
self.next_frame = 0
self.ooo_frames = dict()
self.max_ooo_frames = max_ooo_frames
self.block_size = block_size
self.receive_queues = []
self.perfs = []
def __init__(self, base: FrameGenerator, overlay: FrameGenerator,
pos: typing.Tuple[int, int]):
tus.check(base=(base, FrameGenerator),
overlay=(overlay, FrameGenerator),
pos=(pos, (tuple, list)))
tus.check_listlike(pos=(pos, int, 2))
if (pos[0] < 0 or pos[1] < 0
or pos[0] + overlay.frame_size[0] > base.frame_size[0]
or pos[1] + overlay.frame_size[1] > base.frame_size[1]):
raise ValueError(f'cannot fit overlay at {pos} of size ' +
f'{overlay.frame_size} onto frame of size ' +
str(base.frame_size))
if base.duration != overlay.duration:
raise ValueError(
f'durations dont match: base has {base.duration}' +
f' and overlay has {overlay.duration}')
self.base = base
self.overlay = overlay
self.pos = pos
def __init__(self, children):
tus.check(children=(children, (tuple, list)))
tus.check_listlike(children=(children, Token))
self.children = children
def test_checklistlike_manystr_pass(self):
tus.check_listlike(a=(['a', 'b'], str))
def test_checklistlike_singleint_fail(self):
with self.assertRaises(ValueError):
tus.check_listlike(a=([1], str))
def test_checklistliek_minlen_fail(self):
with self.assertRaises(ValueError):
tus.check_listlike(a=([3.5, 2.5, 1.0], float, (4, None)))
def test_checklistlike_mixed_fail(self):
with self.assertRaises(ValueError):
tus.check_listlike(a=(['a', 5], str))
def test_checklistlike_minlen_pass(self):
tus.check_listlike(a=([3.5, 2.5, 1.0], float, (2, None)))
def test_checklistlike_exactlen_fail(self):
with self.assertRaises(ValueError):
tus.check_listlike(a=([3.5], float, 2))
def test_checklistlike_exactlen_pass(self):
tus.check_listlike(a=([3.5], float, 1))
def test_checklistlike_multiplelist_fail(self):
with self.assertRaises(ValueError):
tus.check_listlike(a=([3.5], float), b=(['john'], float))
def test_checklistlike_multiplelist_pass(self):
tus.check_listlike(a=([3.5], float), b=(['john', 'doe'], str))
