Alter | Alter library and tool uses simple SQL files | Data Migration library

Here's a solution which doesn't return a new function which captures intermediate calculations, but rather calls the given function's code internally. There's some limitations, such as it probably only works with named arguments. Instead of storing the intermediate calculations as an RDS, it attaches them as an attribute.

1. Is this legitimate? Can you point me to where this feature is documented?

This is legitimate. However, using np.view (which is equivalent) is better since it is compatible with a static analysers (so it is somehow safer). Indeed, the documentation states:

It’s possible to mutate the dtype of an array at runtime. [...] This sort of mutation is not allowed by the types. Users who want to write statically typed code should instead use the numpy.ndarray.view method to create a view of the array with a different dtype.

1. Does it in fact leave the data of the array untouched, i.e. no duplication of the data?

Yes. Since the array is still a view on the same internal memory buffer (a basic byte array). Numpy will just reinterpret it differently (this is directly done the C code of each Numpy computing function).

1. What if I want two arrays a and b sharing the same data, but view it as different dtypes? [...]

np.view can be used in this case as you did in your example. However, the result is platform dependent. Indeed, Numpy just reinterpret bytes of memory and theoretically the representation of negative numbers can change from one machine to another. Hopefully, nowadays, all mainstream modern processors use use the two's complement (source). This means that a np.in32 value like -1 will be reinterpreted as 2**32-1 = 4294967295 with a view of type np.uint32. Positive signed values are unchanged. As long as you are aware of this, this is fine and the behaviour is predictable.

1. This can be extended to other dtypes, the most extreme of which is probably mixing 32 and 64 bit floats.

Well, put it shortly, this is really like playing fire. In this case this certainly unsafe although it may work on your specific machine. Let us venturing into troubled waters.

First of all, the documentation of np.view states:

The behavior of the view cannot be predicted just from the superficial appearance of a. It also depends on exactly how a is stored in memory. Therefore if a is C-ordered versus fortran-ordered, versus defined as a slice or transpose, etc., the view may give different results.

The thing is Numpy reinterpret the pointer using a C code. Thus, AFAIK, the strict aliasing rule applies. This means that reinterpreting a np.float32 value to a np.float64 cause an undefined behaviour. One reason is that the alignment requirements are not the same for np.float32 (typically 4) and np.float32 (typically 8) and so reading an unaligned np.float64 value from memory can cause a crash on some architecture (eg. POWER) although x86-64 processors support this. Another reason comes from the compiler which can over-optimize the code due to the strict aliasing rule by making wrong assumptions in your case (like a np.float32 value and a np.float64 value cannot overlap in memory so the modification of the view should not change the original array). However, since Numpy is called from CPython and no function calls are inlined from the interpreter (probably not with Cython), this last point should not be a problem (it may be the case be if you use Numba or any JIT though). Note that this is safe to get an np.uint8 view of a np.float32 since it does not break the strict aliasing rule (and the alignment is Ok). This could be useful to efficiently serialize Numpy arrays. The opposite operation is not safe (especially due to the alignment).

Update about last section: a deeper analysis from the Numpy code show that some part of the code like type-conversion functions perform a safe type punning using the memmove C call, while some other functions like all basic unary operators or binary ones do not appear to do a proper type punning yet! Moreover, such feature is barely tested by users and tricky corner cases are likely to cause weird bugs (especially if you read and write in two views of the same array). Thus, use it at your own risk.

You could use django's receiver annotation.

For example, if you want to detect any call of the save method, you could do:

Think you're missing a using line:

I'd like to be able to build range-queries for all of the following:

Yes, that's really all it is. It may make it easier to think about if you write the signature of twice as

To be clear: you want to know for each be/me value in df which decile it would have fallen into if that value had been in df2? I see two cases:

1. If df2 covers the whole month of June (as you wrote), I am afraid there is no answer to that question: each day in the month will have decile bins with different edges (since you are doing a groupby('date') on df2). The same be/me value in df could belong to different deciles in df2 depending on the day in June you consider.

2. If df2 actually covers only one day in June (as your example above seems to indicate: 2020-06-30), then you have one well defined set of decile bins.

In case 2), you could do that:

You can accomplish this by making your own trait that takes the other traits as a bound, then add a blanket implementation for it:

the role can be the owner and still not have select, insert, update, delete privilege?

Yes. The manual:

An object's owner can choose to revoke their own ordinary privileges, for example to make a table read-only for themselves as well as others. But owners are always treated as holding all grant options, so they can always re-grant their own privileges.

And a superuser can do anything that the owner can do.

Tricky detail: The owner (or a superuser) can REVOKE privileges from himself (the owner). If ownership then changes hands, the new owner inherits the set of privileges that the previous owner had - plus any privileges the new owner might already have held. So the union of the previous privileges of the role and privileges of the owner. Those are then the new privileges of the owner.

If ownership again changes hands, the whole set of privileges is passed on! The previous owner loses all privileges he has held directly.

But any role can inherit additional privileges via membership in another role or via PUBLIC privileges.

Closely related:

• Implicit privileges for schema owner