Skip to main content
100%

Gist 70c868110a00f3ba70900612538f1fce

✓ Published0🌍 Public
Aalpha-beta-soup
Last edited Mar 23, 2017
Created on Mar 23, 2017

This example demonstrates a unit-validation function that checks whether a string represents a valid Pint unit. It defines `is_str_valid_pint_unit` to attempt parsing the input with the Pint `UnitRegistry` and returns `False` when an `UndefinedUnitError` occurs. The code prints `True` for the sample unit `'degC'`, showing how the registry recognizes common units. The example uses the Pint library’s `ureg()` call to perform the validation.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 0350c21c054d3bc0f23d8ddd8c857ed1

This example shows a reusable Python function that converts lists of numeric values between different units of measurement using the Pint library. It defines `convert`, which takes an array, a source unit, and a target unit, then applies Pint’s `Quantity` constructor and `.to()` method to return a list of converted quantities. The code relies on `pint.UnitRegistry` to access unit definitions, as demonstrated in the docstring where inches are converted to meters. The function is designed for interactive use, such as in IPython, to avoid repeating unit conversion logic.

Aalpha-beta-soup
65% match
Loading thumbnail…

Gist 311517677957b0128dbb7f06e746ba86

This visualization demonstrates a compact validation of a Rummikub tile hand using a single regular expression in JavaScript. It shows how a string of digits and letters (`1@23@@678@abc@`) can be parsed to check whether it contains exactly 13 valid tile groups, where groups consist of three or more consecutive numbers or letters with optional wildcard symbols (`@`). The code uses the `String.prototype.match()` API with the regex `/(@*(\d|[abcd]){3,}@*)/g`, then joins matched groups and compares their total length to 13. The example highlights regex-based pattern matching as a concise alternative to procedural tile-grouping logic.

Aamazingandyyy
45% match
Loading thumbnail…

Gist 231720

This example demonstrates a bug in DataMapper validation where a boolean field incorrectly accepts `false` as valid. The code defines a `Foo` resource with an `age_check` Boolean property and a `validates_is_accepted` rule that should reject unaccepted values. Using DataMapper’s `setup` and `auto_migrate!` with an in-memory SQLite database, it creates a new record with `age_check` set to `false` and calls `valid?`, which returns `true` instead of the expected `false`. The snippet highlights the validation’s failure specifically for Boolean types, noting that changing the property to a String resolves the issue.

XXXX
44% match
Loading thumbnail…

Gist 425738

This example demonstrates a Monte Carlo simulation for approximating the value of π by generating random points within a unit square and counting how many fall inside the unit circle. The code uses Go’s standard `rand` package for pseudo-random number generation and `flag` for command-line parameters, with concurrent goroutines and channels to parallelize the sampling across multiple processes. It reports the calculated π value and the execution time in milliseconds, though it produces no visual chart or plot.

Aaht
44% match
Loading thumbnail…

A gist illustrating testing in Python using unittest

This example demonstrates how to structure and execute a Python test suite using the built-in `unittest` framework, alongside `doctest` for embedded documentation checks. It shows the definition of a `factorial` function and a `TestFactorial` class that validates expected outputs, error handling, and edge cases. The code dynamically generates test methods via `setattr` and uses `subTest` for granular failure reporting. It also illustrates skipping tests with `@unittest.skip`, suppressing console logging via `logging.NullHandler`, and controlling output with `unittest.main(buffer=True)`. The visible data source is the hardcoded test case list and doctest examples within the function docstring.

IIanHopkinson
44% match
Loading thumbnail…

Gist 189433

This visualization shows a Ruby data fixture that defines user account attributes for a test suite. It uses the Machinist library’s `User.fix` block to generate randomized login names, emails, and passwords via regex-based `unique` generators, along with nested `Character.make` factories. The code specifies constraints like password confirmation, character count limits, and a boolean agreement flag, demonstrating how to construct realistic test data without a rendering API.

XXXX
44% match
Loading thumbnail…

Gist 6c1ae0e4fff5fb8d4704

This example shows a text-parsing utility that cleans and tokenizes a raw string into lowercase words. It first replaces common punctuation sequences like dashes and double quotes with spaces, then uses a regular expression with Unicode flags to extract word tokens, allowing characters such as `@`, `#`, `&`, and hyphens. The code relies on Python’s standard `re` module and basic string methods, with no external visualization libraries or rendering pipeline. The output is a list of normalized words, illustrating a preprocessing step rather than a visual chart or graph.

Aandyreagan
43% match
Loading thumbnail…

Gist 07c637765f8aad3f648d483be9e42cd8

This example demonstrates basic Python syntax and output within a Jupyter notebook, showing how simple print statements and expression evaluations behave. It highlights the classic floating-point precision issue where `0.1 + 0.2` does not equal `0.3`, and contrasts that with an epsilon-based comparison that returns `True`. The code also illustrates string handling with triple-quoted multiline strings and the difference between echoing a value and using `print()`. No external visualization libraries are used; the focus is purely on language fundamentals.

FFrieseWoudloper
43% match