def numericalize(self, amt):
if amt > 100.0 and amt < 1e6:
return humanize.intcomma(int(amt))
if amt >= 1e6:
return humanize.intword(int(amt))
elif isinstance(amt, int) or amt.is_integer():
return humanize.apnumber(int(amt))
else:
return humanize.fractional(amt)
def _create_quantity_text(self, quantity, unit):
definition = self.definitions[unit]
# Round value
quantity = round(quantity, definition.digits)
# Create text
quantity_str = humanize.fractional(quantity)
unit = ureg(unit).units
return f"{quantity_str} {unit:~P}"
def get(self):
args = parser.parse_args()
start_of_the_day = datetime.combine(date.today(), time())
end_of_the_day = start_of_the_day + timedelta(days=1) - timedelta(
microseconds=1)
processing_time = timedelta(microseconds=0)
count = 0
processed_count = 0
processed_today = 0
total_input_file_size = 0
total_processed_file_size = 0
for media_file in mp.mfq:
if media_file.date_started and media_file.date_finished:
processed_count += 1
processing_time += media_file.date_finished - media_file.date_started
if media_file.date_started >= start_of_the_day and media_file.date_finished <= end_of_the_day:
processed_today += 1
if media_file.transcoded_file_size:
total_processed_file_size += media_file.transcoded_file_size
total_input_file_size += media_file.file_size
count += 1
average_processing_time = QueueStats.mean(processing_time,
processed_count)
average_processed_per_day = QueueStats.mean(
processed_count,
(processing_time.total_seconds() / (60 * 60 * 24)))
average_processed_file_size = total_processed_file_size / processed_count
average_input_file_size = total_input_file_size / count
input_to_processed_file_size_ratio = float(
average_input_file_size) / max(average_processed_file_size, 1)
return {
'processed_today':
apnumber(processed_today) if args.humanize else processed_today,
'average_processed_per_day':
apnumber(average_processed_per_day)
if args.humanize else str(average_processed_per_day),
'average_processing_time':
naturaldelta(average_processing_time)
if args.humanize else str(average_processing_time),
'average_processed_file_size':
naturalsize(average_processed_file_size)
if args.humanize else average_processed_file_size,
'average_input_file_size':
naturalsize(average_input_file_size)
if args.humanize else average_input_file_size,
'input_to_processed_file_size_ratio':
fractional(input_to_processed_file_size_ratio)
if args.humanize else input_to_processed_file_size_ratio
}
def add_ingredient(self, name, quantity, unit=None):
quantity = float(quantity)
# No unit
if not unit:
self.ingredients.setdefault(name, 0.0)
try:
self.ingredients[name] += ureg.Quantity(quantity)
except:
other_unit = self.ingredients[name].units
error = UnitMismatchError(other_unit)
self._log_error(error)
return f"!!!error {error}"
quantity_text = humanize.fractional(quantity)
return f"*{name}* ({quantity_text})"
# Create quantity
try:
uquantity = quantity * ureg(unit)
except:
error = UnknownUnitError(unit)
self._log_error(error)
return f"!!!error {error}"
# Convert to quantity to mass, if possible
if uquantity.check("[mass]") and name in self.densities:
uquantity = uquantity / self.densities[name]
# Add to ingredients
self.ingredients.setdefault(name, 0.0 * uquantity.units)
try:
self.ingredients[name] += uquantity
except:
other_unit = self.ingredients[name].units
error = UnitMismatchError(other_unit)
self._log_error(error)
return f"!!!error {error}"
# No conversion for this ingredient
if name not in self.conversions:
error = NoUnitConversionError(name)
self._log_error(error)
quantity_text = self._create_quantity_text(quantity, unit)
return f"*{name}* ({quantity_text})"
# Apply conversion
equivalences = self._create_equivalences(name, uquantity)
return f"*{name}* (" + " | ".join(equivalences) + ")"
def get_lines(self):
lines = []
for name, uquantity in sorted(self.ingredients.items()):
if uquantity.dimensionless:
quantity_text = humanize.fractional(uquantity.magnitude)
elif name not in self.conversions:
quantity_text = self._create_quantity_text(
uquantity.magnitude, str(uquantity.units))
else:
equivalences = self._create_equivalences(name, uquantity)
quantity_text = " | ".join(equivalences)
lines.append(f"* {name}: {quantity_text}")
lines.append("")
return lines
def test_fractional(test_input, expected):
assert humanize.fractional(test_input) == expected
import humanize assert humanize.intcomma(12345) == '12,345' assert humanize.intword(123455913) == '123.5 million' assert humanize.naturalsize(1000000, binary=True) == '976.6 KiB' assert humanize.fractional(0.3) == '3/10'
async def fractional(self, ctx, *, val: float):
"""Convert a decimal into a more readable fraction"""
await ctx.send(humanize.fractional(val))
