def test_count():
assert count((1, 2, 3)) == 3
assert count([]) == 0
assert count(iter((1, 2, 3, 4))) == 4
assert count('hello') == 5
assert count(iter('hello')) == 5
def get_expected(employee_data, years):
"""
Get the expected percentage of all employees per company that are
specified number of years older than the company-wide average using
python.
:param employee_data: Hypothesis generated employee database source data.
:param years: Find percentage of employees this number of years older
than the company-wide average.
:return: Generator which when iterated yields an instance of ``Expected``
which represents the expected result from get_employees_per_company.
"""
for company, company_employees in get_company_employees(employee_data):
percentage_older = 0
def calc_age(employee):
return (today - employee.date_of_birth).days / 365.25
employee_ages = list(map(calc_age, company_employees))
average_employee_age = statistics.mean(employee_ages)
def is_older(employee_age):
return employee_age > (average_employee_age + years)
n_employees_older = count(filter(is_older, employee_ages))
if n_employees_older:
n_employees = float(len(company_employees))
percentage_older = n_employees_older / n_employees * 100
yield Expected(company.company_id, company.company_name,
average_employee_age, percentage_older)
def test_print_table(labels, title):
table = cli_inference.print_table(labels, title, print=False)
assert isinstance(table, rich.table.Table)
assert table.title == title
unique = itertoolz.count(itertoolz.unique(labels))
assert table.row_count == unique + 1
assert all(label in getattr(itertoolz.first(table.columns), "_cells")
for label in labels)
table = cli_inference.print_table(labels, title, print=True)
def special_issue(self):
"""
checks if paper has been published in Special Issue
"""
def si_dict():
brain = first(paper_view.getSpecialIssues())
return {'title': brain.Title, 'url': brain.getURL}
paper_view = getMultiAdapter((self.context, self.request),
name="paperView")
return count(paper_view.getSpecialIssues()) > 0 and si_dict() or False
def add_async(self, *items):
""" Add additional items to the asynchronous processing queue.
Args:
items (list(Any)): list of items that need processing. Each item is
applied one at a time to an available driver from the pool.
Raises:
StopIteration: when all items have been added.
"""
if len(items) == 1 and isinstance(items[0], list):
items = iter(items[0])
if not items:
raise DriverPoolValueError(
'cannot add items with value: %s' % str(items))
item_count = count(items)
self.logger.debug('adding %d additional items to tasks', item_count)
for o in items:
self._tasks.put(o)
def compress(data: Iterable[T], key: Optional[Callable[[T], Any]] = None) -> Iterable[Tuple[T, int]]:
for k, g in itertools.groupby(data, key=key):
yield (k, itertoolz.count(g))
def matchingfrequencies(*seqs: Iterable[T],
key=None) -> Iterable[Tuple[T, int]]:
for k, g in groupby(merge(*[unique(seq, key=key) for seq in seqs],
key=key)):
yield (k, count(g))
def get_expected(employee_data, location, min_percentage):
"""
Calculate the percentage of employees of a company at a particular location,
filtered by a minimum percentage of employees using python.
:param employee_data: Hypothesis generated employee database source data.
:param location: The location to get employee percentage for. This is a / separated list of
any of the following combinations:
- continent/country/state/city
- continent/country/state
- continent/country
- continent
:param min_percentage: The minimum percentage of employees a location should
have to be included in the output.
:return: Generator which when iterated yields an instance ``Expected`` which represents the
expected result from get_employees_percentage_by_location.
"""
location_fields = ['city', 'state', 'country', 'continent']
continent, country, state, city = (x for x, y in itertools.zip_longest(
location.split('/'), location_fields))
params = Bunch(continent=continent,
country=country,
state=state,
city=city)
def get_location(employee):
return employee_data.locations[employee.location_id - 1]
def are_all_attrs_equal(lhs, rhs, attrs):
return all(getattr(lhs, attr) == getattr(rhs, attr) for attr in attrs)
def get_location_and_where(n):
"""
Get the location to include in the result and a where function to
filter the company employees for inclusion when calculating the
percentage at a location.
"""
fields = location_fields[n:]
filter_func = partial(are_all_attrs_equal, params, attrs=fields)
employee_location = next(filter(filter_func, employee_data.locations))
location = '/'.join(
getattr(employee_location, x) for x in reversed(fields))
def where(employee):
return are_all_attrs_equal(get_location(employee), params, fields)
return location, where
for company, company_employees in get_company_employees(employee_data):
if city:
location, where = get_location_and_where(0)
elif state:
location, where = get_location_and_where(1)
elif country:
location, where = get_location_and_where(2)
else:
location, where = get_location_and_where(3)
n_employees_in_location = count(filter(where, company_employees))
n_employees = float(len(company_employees))
percentage = n_employees_in_location / n_employees * 100
if 0 < percentage > min_percentage:
yield Expected(company.company_id, company.company_name, location,
percentage)
def count_files_with_ext(directory: Path, ext: str) -> int:
"""Counts files matching extension in directory"""
return itertoolz.count(Path(directory).rglob(f"*{ext}"))
def disperse(seq):
"""
Similar to range except that it recursively proceeds through the given
range in such a way that values that follow each other are preferably
not only non-sequential, but fairly different. This does not always
work with small ranges, but works nicely with large ranges.
Args:
a(int): the lower bound of the range
b(int): the upper bound of the range
Returns:
result(generator): a generator that can be used to iterate
through the sequence.
Examples:
>>> list(disperse(range(10)))
[0, 5, 8, 3, 9, 4, 6, 1, 7, 2]
"""
try:
len_seq = len(seq)
except TypeError:
seq, len_seq = itertools.tee(seq)
len_seq = count(len_seq)
def disperse_helper(b, part_seq_1):
if b != 0:
half_diff = float(b) / 2.0
mid_1 = int(math.floor(half_diff))
mid_2 = int(math.ceil(half_diff))
if 0 < mid_1 and b > mid_2:
part_seq_1, part_seq_2 = itertools.tee(part_seq_1)
front_mid_1_seq, mid_1_val, _ = split(mid_1, part_seq_1)
_, mid_2_val, back_mid_2_seq = split(mid_2, part_seq_2)
del _
mid_2_val = itertools.tee(mid_2_val)
back_mid_2_seq = concat([mid_2_val[0], back_mid_2_seq])
mid_2_val = mid_2_val[1]
yield (first(mid_2_val))
for _1, _2 in zip(disperse_helper(mid_1 - 0, front_mid_1_seq),
disperse_helper(b - mid_2, back_mid_2_seq)):
yield (_2)
yield (_1)
if mid_1 != mid_2:
yield (first(mid_1_val))
if len_seq == 0:
return
val, seq = peek(seq)
yield (val)
for each in disperse_helper(len_seq, seq):
yield (each)
