NTP | NTP server clock on ESP32 with built-in OLED display | Date Time Utils library

Your tick period: ¹/_268'435'455 is unfortunately both extremely fine and also doesn't lend itself to much of a reduced fraction when your desired conversions are used (i.e. between system_clock::duration and NTPClock::duration. This is leading to internal overflow of your unsigned long long NTPClock::rep.

For example, on Windows the system_clock tick period is ¹/_10,000,000 seconds. The current value of now() is around 1.6 x 10¹⁶. To convert this to NTPClock::duration you have to compute 1.6 x 10¹⁶ times ^53,687,091/_2,000,000. The first step in that is the value times the numerator of the conversion factor which is about 8 x 10²³, which overflows unsigned long long.

There's a couple of ways to overcome this overflow, and both involve using at least an intermediate representation with a larger range. One could use a 128 bit integral type, but I don't believe that is available on Windows, except perhaps by a 3rd party library. long double is another option. This might look like:

try this solution:

Read the data and create the variables finallist and input

You will have to use dict2items on the elements of your input_var.Stores list, in order to make it more queryable. You can apply this filter on all the items of the list, with the help of map.

Then you fall back to what you where trying to do, a selectattr to fetch the element that correspond to the CIDR of the input item your are currently looping on. On a list, this can be achieved with the help of the contains test that Ansible provides on top on Jinja builtin tests.

Which ends up in this set_fact:

It is all about quotes.

To click on the element you can use either of the following locator strategies:

• cssSelector:

YAML supports anchors and aliases, but this feature does not support the arbitrary placement of placeholders and expressions anywhere in the YAML text. They only work with YAML nodes.

You will need to use a YAML extension library or process this .yml in some programming language to replace these placeholders.

You can find more details in this related question: Use placeholders in yaml.

There are several aspects here ...

First: the optimizer is free to apply the predicates in any order. In your case, it looks like it applies the spatial filter first, then applies the selector on number of vertices. Which means you get the exception before the test on number of vertices.

That the optimizer does this is natural: changing the order would mean a full table scan to only return the geometries with 4 points or more, then pass the result through the spatial filter. That would be very slow, and the optimizer rightfully prefers using the index first.

There is no mechanism (hints or otherwise) to control this behavior. Using a subquery or a view will not make any difference: the optimizer will flatten the query into a simple one. Possibly a subquery with a NO_MERGE hint could work: but it would have the above effect of forcing a full table scan and a full pass of all geometries through the spatial filter. Not a good thing.

Second: polygons with less than 4 vertices are incorrect. The simplest polygon is a triangle. It has three points (A-B-C), but all polygons must close, i.e. be encoded as four vertices: A-B-C-A. That is one of the rules defined by the OGC Simple Features for SQL specification. There are others that polygons must adhere to:

• Absence of redundant vertices
• Orientation (counter-clockwise for outer rings, clockwise for inner rings, i.e. holes)
• Absence of self touching rings
• Ordering of the rings (an outer ring must be followed by its inner rings)

Shapes that do not adhere to the rules are invalid. What happens when you use invalid shapes is actually undefined. Depending on the nature of the error and the action you do on this shape (query, measure, buffer, clip, merge ...), you may get any of the following behaviors:

1. the error is ignored and you get a correct result
2. you get an exception (that is your case)
3. you get no error, but the result is incorrect

The worst possible outcome is #3: you cannot trust the results of your application. It may return the wrong area in m2 of a parcel. Or it may say that two adjacent parcels do not overlap, when in reality they do ... This is very bad.

Data quality is of prime importance when manipulating and processing spatial data. Note that errors are generally not visible: most map-mapping tools are resilient enough to still show the shapes, and defects are for the most impossible to detect visually.

The solution is simple: make sure your data is valid. For that you can use the SDO_GEOM.VALIDATE_GEOMETRY_WITH_CONTEXT(). Run it over each shape. It will tell you which shapes are incorrect, and what the error is.

There is also SDO_UTIL.RECTIFY_GEOMETRY(). This one will attempt to correct the most common errors:

• Removes redundant vertices
• Reorients and re-orders rings
• Corrects some self-orientations

It does not correct the errors you see (less than four points) because it is uncertain of what is actually wrong. You need to look at what those shapes are, and more important where they came from. Then either correct them or remove them.

You can achieve this with the usage of filters only.

Given the two yaml — abc.yml and var.yml — you provided, using this two tasks: