Is there anyone try to extend Conv2DLSTM to Conv3DLSTM?

Please make sure that this is a Bug or a Feature Request and provide all applicable information asked by the template.
If your issue is an implementation question, please ask your question on StackOverflow or on the Keras Slack channel instead of opening a GitHub issue.
System information

Have I written custom code (as opposed to using example directory):
OS Platform and Distribution (e.g., Linux Ubuntu 16.04):
TensorFlow backend (yes / no):
TensorFlow version:
Keras version:
Python version:
CUDA/cuDNN version:
GPU model and memory:

You can obtain the TensorFlow version with:
python -c "import tensorflow as tf; print(tf.GIT_VERSION, tf.VERSION)"
You can obtain the Keras version with:
python -c 'import keras as k; print(k.version)'
Describe the current behavior
Describe the expected behavior
Code to reproduce the issue
Provide a reproducible test case that is the bare minimum necessary to generate the problem.
Other info / logs
Include any logs or source code that would be helpful to diagnose the problem. If including tracebacks, please include the full traceback. Large logs and files should be attached.

@zhqshen Could you provide more details on the feature you are requesting? Could you mention some of the use cases for the new feature? Thanks!

I want to use 3d images (volumns) in the process of cnn and with lstm in the time axis. I try to extend operation of conv2dlstm to conv3dlstm by replacing the conv2d with conv3d, and failed. I'm new for keras.
##############
convolutional_recurrent_3d.py

-- coding: utf-8 --
"""Convolutional-recurrent layers.
"""
from future import absolute_import
from future import division
from future import print_function
from .. import backend as K
from .. import activations
from .. import initializers
from .. import regularizers
from .. import constraints
from .recurrent import _generate_dropout_mask
from .recurrent import _standardize_args
import numpy as np
import warnings
from ..engine.base_layer import InputSpec, Layer
from ..utils import conv_utils
from ..legacy import interfaces
from ..legacy.layers import Recurrent, ConvRecurrent2D
from .recurrent import RNN
from ..utils.generic_utils import has_arg
from ..utils.generic_utils import to_list
from ..utils.generic_utils import transpose_shape
class ConvRNN3D(RNN):
"""Base class for convolutional-recurrent layers.
# Arguments
    cell: A RNN cell instance. A RNN cell is a class that has:
        - a `call(input_at_t, states_at_t)` method, returning
          `(output_at_t, states_at_t_plus_1)`. The call method of the
          cell can also take the optional argument `constants`, see
          section "Note on passing external constants" below.
        - a `state_size` attribute. This can be a single integer (single state)
          in which case it is the number of channels of the recurrent state
          (which should be the same as the number of channels of the cell
          output). This can also be a list/tuple of integers
          (one size per state). In this case, the first entry (`state_size[0]`)
          should be the same as the size of the cell output.
    return_sequences: Boolean. Whether to return the last output.
        in the output sequence, or the full sequence.
    return_state: Boolean. Whether to return the last state
        in addition to the output.
    go_backwards: Boolean (default False).
        If True, process the input sequence backwards and return the
        reversed sequence.
    stateful: Boolean (default False). If True, the last state
        for each sample at index i in a batch will be used as initial
        state for the sample of index i in the following batch.
    input_shape: Use this argument to specify the shape of the
        input when this layer is the first one in a model.

# Input shape
    6D tensor with shape:
    `(samples, timesteps, channels, rows, cols, vols)` if data_format='channels_first'
    or 5D tensor with shape:
    `(samples, timesteps, rows, cols, vols, channels)` if data_format='channels_last'.

# Output shape
    - if `return_state`: a list of tensors. The first tensor is
        the output. The remaining tensors are the last states,
        each 6D tensor with shape:
        `(samples, timesteps,
          filters, new_rows, new_cols, new_vols)` if data_format='channels_first'
        or 5D tensor with shape:
        `(samples, timesteps,
          new_rows, new_cols, new_vols, filters)` if data_format='channels_last'.
        `rows`, `cols` and 'vols' values might have changed due to padding.
    - if `return_sequences`: 6D tensor with shape:
        `(samples, timesteps,
          filters, new_rows, new_cols, new_vols)` if data_format='channels_first'
        or 6D tensor with shape:
        `(samples, timesteps,
          new_rows, new_cols, new_vols, filters)` if data_format='channels_last'.
    - else, 5D tensor with shape:
        `(samples, filters, new_rows, new_cols, new_vols)` if data_format='channels_first'
        or 5D tensor with shape:
        `(samples, new_rows, new_cols, new_vols, filters)` if data_format='channels_last'.

# Masking
    This layer supports masking for input data with a variable number
    of timesteps. To introduce masks to your data,
    use an [Embedding](embeddings.md) layer with the `mask_zero` parameter
    set to `True`.

# Note on using statefulness in RNNs
    You can set RNN layers to be 'stateful', which means that the states
    computed for the samples in one batch will be reused as initial states
    for the samples in the next batch. This assumes a one-to-one mapping
    between samples in different successive batches.

    To enable statefulness:
        - specify `stateful=True` in the layer constructor.
        - specify a fixed batch size for your model, by passing
             - if sequential model:
                `batch_input_shape=(...)` to the first layer in your model.
             - if functional model with 1 or more Input layers:
                `batch_shape=(...)` to all the first layers in your model.
                This is the expected shape of your inputs
                *including the batch size*.
                It should be a tuple of integers, e.g. `(32, 10, 100, 100, 100, 32)`.
                Note that the number of rows, columns and vols should be specified too.
        - specify `shuffle=False` when calling fit().

    To reset the states of your model, call `.reset_states()` on either
    a specific layer, or on your entire model.

# Note on specifying the initial state of RNNs
    You can specify the initial state of RNN layers symbolically by
    calling them with the keyword argument `initial_state`. The value of
    `initial_state` should be a tensor or list of tensors representing
    the initial state of the RNN layer.

    You can specify the initial state of RNN layers numerically by
    calling `reset_states` with the keyword argument `states`. The value of
    `states` should be a numpy array or list of numpy arrays representing
    the initial state of the RNN layer.

# Note on passing external constants to RNNs
    You can pass "external" constants to the cell using the `constants`
    keyword argument of `RNN.__call__` (as well as `RNN.call`) method. This
    requires that the `cell.call` method accepts the same keyword argument
    `constants`. Such constants can be used to condition the cell
    transformation on additional static inputs (not changing over time),
    a.k.a. an attention mechanism.
"""

def __init__(self, cell,
             return_sequences=False,
             return_state=False,
             go_backwards=False,
             stateful=False,
             unroll=False,
             **kwargs):
    if unroll:
        raise TypeError('Unrolling isn\'t possible with '
                        'convolutional RNNs.')
    if isinstance(cell, (list, tuple)):
        # The StackedConvRNN2DCells isn't implemented yet.
        raise TypeError('It is not possible at the moment to'
                        'stack convolutional cells.')
    super(ConvRNN3D, self).__init__(cell,
                                    return_sequences,
                                    return_state,
                                    go_backwards,
                                    stateful,
                                    unroll,
                                    **kwargs)
    self.input_spec = [InputSpec(ndim=6)]

def compute_output_shape(self, input_shape):
    if isinstance(input_shape, list):
        input_shape = input_shape[0]

    cell = self.cell
    if cell.data_format == 'channels_first':
        rows = input_shape[3]
        cols = input_shape[4]
        vols = input_shape[5]
    elif cell.data_format == 'channels_last':
        rows = input_shape[2]
        cols = input_shape[3]
        vols = input_shape[4]
    rows = conv_utils.conv_output_length(rows,
                                         cell.kernel_size[0],
                                         padding=cell.padding,
                                         stride=cell.strides[0],
                                         dilation=cell.dilation_rate[0])
    cols = conv_utils.conv_output_length(cols,
                                         cell.kernel_size[1],
                                         padding=cell.padding,
                                         stride=cell.strides[1],
                                         dilation=cell.dilation_rate[1])
    vols = conv_utils.conv_output_length(vols,
                                         cell.kernel_size[2],
                                         padding=cell.padding,
                                         stride=cell.strides[2],
                                         dilation=cell.dilation_rate[2])

    output_shape = input_shape[:2] + (rows, cols, vols, cell.filters)
    output_shape = transpose_shape(output_shape, cell.data_format,
                                   spatial_axes=(2, 3, 4))

    if not self.return_sequences:
        output_shape = output_shape[:1] + output_shape[2:] + output_shape[3:]

    if self.return_state:
        output_shape = [output_shape]
        base = (input_shape[0], rows, cols, vols, cell.filters)
        base = transpose_shape(base, cell.data_format, spatial_axes=(1, 2, 3))
        output_shape += [base[:] for _ in range(3)]
    return output_shape

def build(self, input_shape):
    # Note input_shape will be list of shapes of initial states and
    # constants if these are passed in __call__.
    if self._num_constants is not None:
        constants_shape = input_shape[-self._num_constants:]
    else:
        constants_shape = None

    if isinstance(input_shape, list):
        input_shape = input_shape[0]

    batch_size = input_shape[0] if self.stateful else None
    self.input_spec[0] = InputSpec(shape=(batch_size, None) + input_shape[2:6])

    # allow cell (if layer) to build before we set or validate state_spec
    if isinstance(self.cell, Layer):
        step_input_shape = (input_shape[0],) + input_shape[2:]  ##not modified
        if constants_shape is not None:
            self.cell.build([step_input_shape] + constants_shape)
        else:
            self.cell.build(step_input_shape)

    # set or validate state_spec
    if hasattr(self.cell.state_size, '__len__'):
        state_size = list(self.cell.state_size)
    else:
        state_size = [self.cell.state_size]

    if self.state_spec is not None:
        # initial_state was passed in call, check compatibility
        if self.cell.data_format == 'channels_first':
            ch_dim = 1
        elif self.cell.data_format == 'channels_last':
            ch_dim = 4
        if not [spec.shape[ch_dim] for spec in self.state_spec] == state_size:
            raise ValueError(
                'An initial_state was passed that is not compatible with '
                '`cell.state_size`. Received `state_spec`={}; '
                'However `cell.state_size` is '
                '{}'.format([spec.shape for spec in self.state_spec],
                            self.cell.state_size))
    else:
        if self.cell.data_format == 'channels_first':
            self.state_spec = [InputSpec(shape=(None, dim, None, None, None))
                               for dim in state_size]
        elif self.cell.data_format == 'channels_last':
            self.state_spec = [InputSpec(shape=(None, None, None, None, dim))
                               for dim in state_size]
    if self.stateful:
        self.reset_states()
    self.built = True

def get_initial_state(self, inputs):
    # (samples, timesteps, rows, cols, vols, filters)
    initial_state = K.zeros_like(inputs)
    # (samples, rows, cols, vols, filters)
    initial_state = K.sum(initial_state, axis=1)
    shape = list(self.cell.kernel_shape)
    shape[-1] = self.cell.filters
    initial_state = self.cell.input_conv(initial_state,
                                         K.zeros(tuple(shape)),
                                         padding=self.cell.padding)
    # Fix for Theano because it needs
    # K.int_shape to work in call() with initial_state.
    keras_shape = list(K.int_shape(inputs))
    keras_shape.pop(1)
    if K.image_data_format() == 'channels_first':
        indices = 2, 3, 4
    else:
        indices = 1, 2, 3
    for i, j in enumerate(indices):  #not modified
        keras_shape[j] = conv_utils.conv_output_length(
            keras_shape[j],
            shape[i],
            padding=self.cell.padding,
            stride=self.cell.strides[i],
            dilation=self.cell.dilation_rate[i])
    initial_state._keras_shape = keras_shape

    if hasattr(self.cell.state_size, '__len__'):
        return [initial_state for _ in self.cell.state_size]
    else:
        return [initial_state]

def __call__(self, inputs, initial_state=None, constants=None, **kwargs):
    inputs, initial_state, constants = _standardize_args(
        inputs, initial_state, constants, self._num_constants)

    if initial_state is None and constants is None:
        return super(ConvRNN3D, self).__call__(inputs, **kwargs)

    # If any of `initial_state` or `constants` are specified and are Keras
    # tensors, then add them to the inputs and temporarily modify the
    # input_spec to include them.

    additional_inputs = []
    additional_specs = []
    if initial_state is not None:
        kwargs['initial_state'] = initial_state
        additional_inputs += initial_state
        self.state_spec = []
        for state in initial_state:
            try:
                shape = K.int_shape(state)
            # Fix for Theano
            except TypeError:
                shape = tuple(None for _ in range(K.ndim(state)))
            self.state_spec.append(InputSpec(shape=shape))

        additional_specs += self.state_spec
    if constants is not None:
        kwargs['constants'] = constants
        additional_inputs += constants
        self.constants_spec = [InputSpec(shape=K.int_shape(constant))
                               for constant in constants]
        self._num_constants = len(constants)
        additional_specs += self.constants_spec
    # at this point additional_inputs cannot be empty
    for tensor in additional_inputs:
        if K.is_keras_tensor(tensor) != K.is_keras_tensor(additional_inputs[0]):
            raise ValueError('The initial state or constants of an RNN'
                             ' layer cannot be specified with a mix of'
                             ' Keras tensors and non-Keras tensors')

    if K.is_keras_tensor(additional_inputs[0]):
        # Compute the full input spec, including state and constants
        full_input = [inputs] + additional_inputs
        full_input_spec = self.input_spec + additional_specs
        # Perform the call with temporarily replaced input_spec
        original_input_spec = self.input_spec
        self.input_spec = full_input_spec
        output = super(ConvRNN3D, self).__call__(full_input, **kwargs)
        self.input_spec = original_input_spec
        return output
    else:
        return super(ConvRNN3D, self).__call__(inputs, **kwargs)

def call(self,
         inputs,
         mask=None,
         training=None,
         initial_state=None,
         constants=None):
    # note that the .build() method of subclasses MUST define
    # self.input_spec and self.state_spec with complete input shapes.
    if isinstance(inputs, list):
        inputs = inputs[0]
    if initial_state is not None:
        pass
    elif self.stateful:
        initial_state = self.states
    else:
        initial_state = self.get_initial_state(inputs)

    if isinstance(mask, list):
        mask = mask[0]

    if len(initial_state) != len(self.states):
        raise ValueError('Layer has ' + str(len(self.states)) +
                         ' states but was passed ' +
                         str(len(initial_state)) +
                         ' initial states.')
    timesteps = K.int_shape(inputs)[1]

    kwargs = {}
    if has_arg(self.cell.call, 'training'):
        kwargs['training'] = training

    if constants:
        if not has_arg(self.cell.call, 'constants'):
            raise ValueError('RNN cell does not support constants')

        def step(inputs, states):
            constants = states[-self._num_constants:]
            states = states[:-self._num_constants]
            return self.cell.call(inputs, states, constants=constants,
                                  **kwargs)
    else:
        def step(inputs, states):
            return self.cell.call(inputs, states, **kwargs)

    last_output, outputs, states = K.rnn(step,
                                         inputs,
                                         initial_state,
                                         constants=constants,
                                         go_backwards=self.go_backwards,
                                         mask=mask,
                                         input_length=timesteps)
    if self.stateful:
        updates = []
        for i in range(len(states)):
            updates.append((self.states[i], states[i]))
        self.add_update(updates, inputs)

    if self.return_sequences:
        output = outputs
    else:
        output = last_output

    # Properly set learning phase
    if getattr(last_output, '_uses_learning_phase', False):
        output._uses_learning_phase = True

    if self.return_state:
        states = to_list(states, allow_tuple=True)
        return [output] + states
    else:
        return output

def reset_states(self, states=None):
    if not self.stateful:
        raise AttributeError('Layer must be stateful.')
    input_shape = self.input_spec[0].shape
    state_shape = self.compute_output_shape(input_shape)
    if self.return_state:
        state_shape = state_shape[0]
    if self.return_sequences:
        state_shape = state_shape[:1] + state_shape[2:] #not modified
    if None in state_shape:
        raise ValueError('If a RNN is stateful, it needs to know '
                         'its batch size. Specify the batch size '
                         'of your input tensors: \n'
                         '- If using a Sequential model, '
                         'specify the batch size by passing '
                         'a `batch_input_shape` '
                         'argument to your first layer.\n'
                         '- If using the functional API, specify '
                         'the time dimension by passing a '
                         '`batch_shape` argument to your Input layer.\n'
                         'The same thing goes for the number of rows '
                         'and columns.')

    # helper function
    def get_tuple_shape(nb_channels):
        result = list(state_shape)
        if self.cell.data_format == 'channels_first':
            result[1] = nb_channels
        elif self.cell.data_format == 'channels_last':
            result[4] = nb_channels
        else:
            raise KeyError
        return tuple(result)

    # initialize state if None
    if self.states[0] is None:
        if hasattr(self.cell.state_size, '__len__'):
            self.states = [K.zeros(get_tuple_shape(dim))
                           for dim in self.cell.state_size]
        else:
            self.states = [K.zeros(get_tuple_shape(self.cell.state_size))]
    elif states is None:
        if hasattr(self.cell.state_size, '__len__'):
            for state, dim in zip(self.states, self.cell.state_size):
                K.set_value(state, np.zeros(get_tuple_shape(dim)))
        else:
            K.set_value(self.states[0],
                        np.zeros(get_tuple_shape(self.cell.state_size)))
    else:
        states = to_list(states, allow_tuple=True)
        if len(states) != len(self.states):
            raise ValueError('Layer ' + self.name + ' expects ' +
                             str(len(self.states)) + ' states, '
                             'but it received ' + str(len(states)) +
                             ' state values. Input received: ' +
                             str(states))
        for index, (value, state) in enumerate(zip(states, self.states)):
            if hasattr(self.cell.state_size, '__len__'):
                dim = self.cell.state_size[index]
            else:
                dim = self.cell.state_size
            if value.shape != get_tuple_shape(dim):
                raise ValueError('State ' + str(index) +
                                 ' is incompatible with layer ' +
                                 self.name + ': expected shape=' +
                                 str(get_tuple_shape(dim)) +
                                 ', found shape=' + str(value.shape))
            # TODO: consider batch calls to `set_value`.
            K.set_value(state, value)

class ConvLSTM3DCell(Layer):
"""Cell class for the ConvLSTM3D layer.
# Arguments
    filters: Integer, the dimensionality of the output space
        (i.e. the number of output filters in the convolution).
    kernel_size: An integer or tuple/list of n integers, specifying the
        dimensions of the convolution window.
    strides: An integer or tuple/list of n integers,
        specifying the strides of the convolution.
        Specifying any stride value != 1 is incompatible with specifying
        any `dilation_rate` value != 1.
    padding: One of `"valid"` or `"same"` (case-insensitive).
    data_format: A string,
        one of `"channels_last"` (default) or `"channels_first"`.
        It defaults to the `image_data_format` value found in your
        Keras config file at `~/.keras/keras.json`.
        If you never set it, then it will be `"channels_last"`.
    dilation_rate: An integer or tuple/list of n integers, specifying
        the dilation rate to use for dilated convolution.
        Currently, specifying any `dilation_rate` value != 1 is
        incompatible with specifying any `strides` value != 1.
    activation: Activation function to use
        (see [activations](../activations.md)).
        If you don't specify anything, no activation is applied
        (ie. "linear" activation: `a(x) = x`).
    recurrent_activation: Activation function to use
        for the recurrent step
        (see [activations](../activations.md)).
    use_bias: Boolean, whether the layer uses a bias vector.
    kernel_initializer: Initializer for the `kernel` weights matrix,
        used for the linear transformation of the inputs.
        (see [initializers](../initializers.md)).
    recurrent_initializer: Initializer for the `recurrent_kernel`
        weights matrix,
        used for the linear transformation of the recurrent state.
        (see [initializers](../initializers.md)).
    bias_initializer: Initializer for the bias vector
        (see [initializers](../initializers.md)).
    unit_forget_bias: Boolean.
        If True, add 1 to the bias of the forget gate at initialization.
        Use in combination with `bias_initializer="zeros"`.
        This is recommended in [Jozefowicz et al.]
        (http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf).
    kernel_regularizer: Regularizer function applied to
        the `kernel` weights matrix
        (see [regularizer](../regularizers.md)).
    recurrent_regularizer: Regularizer function applied to
        the `recurrent_kernel` weights matrix
        (see [regularizer](../regularizers.md)).
    bias_regularizer: Regularizer function applied to the bias vector
        (see [regularizer](../regularizers.md)).
    kernel_constraint: Constraint function applied to
        the `kernel` weights matrix
        (see [constraints](../constraints.md)).
    recurrent_constraint: Constraint function applied to
        the `recurrent_kernel` weights matrix
        (see [constraints](../constraints.md)).
    bias_constraint: Constraint function applied to the bias vector
        (see [constraints](../constraints.md)).
    dropout: Float between 0 and 1.
        Fraction of the units to drop for
        the linear transformation of the inputs.
    recurrent_dropout: Float between 0 and 1.
        Fraction of the units to drop for
        the linear transformation of the recurrent state.
"""

def __init__(self, filters,
             kernel_size,
             strides=(1, 1, 1),
             padding='valid',
             data_format=None,
             dilation_rate=(1, 1, 1),
             activation='tanh',
             recurrent_activation='hard_sigmoid',
             use_bias=True,
             kernel_initializer='glorot_uniform',
             recurrent_initializer='orthogonal',
             bias_initializer='zeros',
             unit_forget_bias=True,
             kernel_regularizer=None,
             recurrent_regularizer=None,
             bias_regularizer=None,
             kernel_constraint=None,
             recurrent_constraint=None,
             bias_constraint=None,
             dropout=0.,
             recurrent_dropout=0.,
             **kwargs):
    super(ConvLSTM3DCell, self).__init__(**kwargs)
    self.filters = filters
    self.kernel_size = conv_utils.normalize_tuple(kernel_size, 3, 'kernel_size')  #2
    self.strides = conv_utils.normalize_tuple(strides, 3, 'strides')   #2
    self.padding = conv_utils.normalize_padding(padding)
    self.data_format = K.normalize_data_format(data_format)
    self.dilation_rate = conv_utils.normalize_tuple(dilation_rate, 3,
                                                    'dilation_rate')   #2
    self.activation = activations.get(activation)
    self.recurrent_activation = activations.get(recurrent_activation)
    self.use_bias = use_bias

    self.kernel_initializer = initializers.get(kernel_initializer)
    self.recurrent_initializer = initializers.get(recurrent_initializer)
    self.bias_initializer = initializers.get(bias_initializer)
    self.unit_forget_bias = unit_forget_bias

    self.kernel_regularizer = regularizers.get(kernel_regularizer)
    self.recurrent_regularizer = regularizers.get(recurrent_regularizer)
    self.bias_regularizer = regularizers.get(bias_regularizer)

    self.kernel_constraint = constraints.get(kernel_constraint)
    self.recurrent_constraint = constraints.get(recurrent_constraint)
    self.bias_constraint = constraints.get(bias_constraint)

    if K.backend() == 'theano' and (dropout or recurrent_dropout):
        warnings.warn(
            'RNN dropout is no longer supported with the Theano backend '
            'due to technical limitations. '
            'You can either set `dropout` and `recurrent_dropout` to 0, '
            'or use the TensorFlow backend.')
        dropout = 0.
        recurrent_dropout = 0.
    self.dropout = min(1., max(0., dropout))
    self.recurrent_dropout = min(1., max(0., recurrent_dropout))
    self.state_size = (self.filters, self.filters)
    self._dropout_mask = None
    self._recurrent_dropout_mask = None

def build(self, input_shape):

    if self.data_format == 'channels_first':
        channel_axis = 1
    else:
        channel_axis = -1
    if input_shape[channel_axis] is None:
        raise ValueError('The channel dimension of the inputs '
                         'should be defined. Found `None`.')
    input_dim = input_shape[channel_axis]
    kernel_shape = self.kernel_size + (input_dim, self.filters * 4)
    self.kernel_shape = kernel_shape
    recurrent_kernel_shape = self.kernel_size + (self.filters, self.filters * 4)

    self.kernel = self.add_weight(shape=kernel_shape,
                                  initializer=self.kernel_initializer,
                                  name='kernel',
                                  regularizer=self.kernel_regularizer,
                                  constraint=self.kernel_constraint)
    self.recurrent_kernel = self.add_weight(
        shape=recurrent_kernel_shape,
        initializer=self.recurrent_initializer,
        name='recurrent_kernel',
        regularizer=self.recurrent_regularizer,
        constraint=self.recurrent_constraint)
    if self.use_bias:
        if self.unit_forget_bias:
            def bias_initializer(_, *args, **kwargs):
                return K.concatenate([
                    self.bias_initializer((self.filters,), *args, **kwargs),
                    initializers.Ones()((self.filters,), *args, **kwargs),
                    self.bias_initializer((self.filters * 2,), *args, **kwargs),
                ])
        else:
            bias_initializer = self.bias_initializer
        self.bias = self.add_weight(shape=(self.filters * 4,),
                                    name='bias',
                                    initializer=bias_initializer,
                                    regularizer=self.bias_regularizer,
                                    constraint=self.bias_constraint)
    else:
        self.bias = None

    self.kernel_i = self.kernel[:, :, :, :self.filters]
    self.recurrent_kernel_i = self.recurrent_kernel[:, :, :, :self.filters]
    self.kernel_f = self.kernel[:, :, :, self.filters: self.filters * 2]
    self.recurrent_kernel_f = (
        self.recurrent_kernel[:, :, :, self.filters: self.filters * 2])
    self.kernel_c = self.kernel[:, :, :, self.filters * 2: self.filters * 3]
    self.recurrent_kernel_c = (
        self.recurrent_kernel[:, :, :, self.filters * 2: self.filters * 3])
    self.kernel_o = self.kernel[:, :, :, self.filters * 3:]
    self.recurrent_kernel_o = self.recurrent_kernel[:, :, :, self.filters * 3:]

    if self.use_bias:
        self.bias_i = self.bias[:self.filters]
        self.bias_f = self.bias[self.filters: self.filters * 2]
        self.bias_c = self.bias[self.filters * 2: self.filters * 3]
        self.bias_o = self.bias[self.filters * 3:]
    else:
        self.bias_i = None
        self.bias_f = None
        self.bias_c = None
        self.bias_o = None
    self.built = True

def call(self, inputs, states, training=None):
    if 0 < self.dropout < 1 and self._dropout_mask is None:
        self._dropout_mask = _generate_dropout_mask(
            K.ones_like(inputs),
            self.dropout,
            training=training,
            count=4)
    if (0 < self.recurrent_dropout < 1 and
            self._recurrent_dropout_mask is None):
        self._recurrent_dropout_mask = _generate_dropout_mask(
            K.ones_like(states[1]),
            self.recurrent_dropout,
            training=training,
            count=4)

    # dropout matrices for input units
    dp_mask = self._dropout_mask
    # dropout matrices for recurrent units
    rec_dp_mask = self._recurrent_dropout_mask

    h_tm1 = states[0]  # previous memory state
    c_tm1 = states[1]  # previous carry state

    if 0 < self.dropout < 1.:
        inputs_i = inputs * dp_mask[0]
        inputs_f = inputs * dp_mask[1]
        inputs_c = inputs * dp_mask[2]
        inputs_o = inputs * dp_mask[3]
    else:
        inputs_i = inputs
        inputs_f = inputs
        inputs_c = inputs
        inputs_o = inputs

    if 0 < self.recurrent_dropout < 1.:
        h_tm1_i = h_tm1 * rec_dp_mask[0]
        h_tm1_f = h_tm1 * rec_dp_mask[1]
        h_tm1_c = h_tm1 * rec_dp_mask[2]
        h_tm1_o = h_tm1 * rec_dp_mask[3]
    else:
        h_tm1_i = h_tm1
        h_tm1_f = h_tm1
        h_tm1_c = h_tm1
        h_tm1_o = h_tm1

    x_i = self.input_conv(inputs_i, self.kernel_i, self.bias_i,
                          padding=self.padding)
    x_f = self.input_conv(inputs_f, self.kernel_f, self.bias_f,
                          padding=self.padding)
    x_c = self.input_conv(inputs_c, self.kernel_c, self.bias_c,
                          padding=self.padding)
    x_o = self.input_conv(inputs_o, self.kernel_o, self.bias_o,
                          padding=self.padding)
    h_i = self.recurrent_conv(h_tm1_i,
                              self.recurrent_kernel_i)
    h_f = self.recurrent_conv(h_tm1_f,
                              self.recurrent_kernel_f)
    h_c = self.recurrent_conv(h_tm1_c,
                              self.recurrent_kernel_c)
    h_o = self.recurrent_conv(h_tm1_o,
                              self.recurrent_kernel_o)

    i = self.recurrent_activation(x_i + h_i)
    f = self.recurrent_activation(x_f + h_f)
    c = f * c_tm1 + i * self.activation(x_c + h_c)
    o = self.recurrent_activation(x_o + h_o)
    h = o * self.activation(c)

    if 0 < self.dropout + self.recurrent_dropout:
        if training is None:
            h._uses_learning_phase = True

    return h, [h, c]

def input_conv(self, x, w, b=None, padding='valid'):
    conv_out = K.conv3d(x, w, strides=self.strides,
                        padding=padding,
                        data_format=self.data_format,
                        dilation_rate=self.dilation_rate)
    if b is not None:
        conv_out = K.bias_add(conv_out, b,
                              data_format=self.data_format)
    return conv_out

def recurrent_conv(self, x, w):
    conv_out = K.conv3d(x, w, strides=(1, 1, 1),
                        padding='same',
                        data_format=self.data_format)
    return conv_out

def get_config(self):
    config = {'filters': self.filters,
              'kernel_size': self.kernel_size,
              'strides': self.strides,
              'padding': self.padding,
              'data_format': self.data_format,
              'dilation_rate': self.dilation_rate,
              'activation': activations.serialize(self.activation),
              'recurrent_activation':
                  activations.serialize(self.recurrent_activation),
              'use_bias': self.use_bias,
              'kernel_initializer':
                  initializers.serialize(self.kernel_initializer),
              'recurrent_initializer':
                  initializers.serialize(self.recurrent_initializer),
              'bias_initializer': initializers.serialize(self.bias_initializer),
              'unit_forget_bias': self.unit_forget_bias,
              'kernel_regularizer':
                  regularizers.serialize(self.kernel_regularizer),
              'recurrent_regularizer':
                  regularizers.serialize(self.recurrent_regularizer),
              'bias_regularizer': regularizers.serialize(self.bias_regularizer),
              'kernel_constraint':
                  constraints.serialize(self.kernel_constraint),
              'recurrent_constraint':
                  constraints.serialize(self.recurrent_constraint),
              'bias_constraint': constraints.serialize(self.bias_constraint),
              'dropout': self.dropout,
              'recurrent_dropout': self.recurrent_dropout}
    base_config = super(ConvLSTM3DCell, self).get_config()
    return dict(list(base_config.items()) + list(config.items()))

class ConvLSTM3D(ConvRNN3D):
"""Convolutional LSTM.
It is similar to an LSTM layer, but the input transformations
and recurrent transformations are both convolutional.

# Arguments
    filters: Integer, the dimensionality of the output space
        (i.e. the number output of filters in the convolution).
    kernel_size: An integer or tuple/list of n integers, specifying the
        dimensions of the convolution window.
    strides: An integer or tuple/list of n integers,
        specifying the strides of the convolution.
        Specifying any stride value != 1 is incompatible with specifying
        any `dilation_rate` value != 1.
    padding: One of `"valid"` or `"same"` (case-insensitive).
    data_format: A string,
        one of `"channels_last"` (default) or `"channels_first"`.
        The ordering of the dimensions in the inputs.
        `"channels_last"` corresponds to inputs with shape
        `(batch, time, ..., channels)`
        while `"channels_first"` corresponds to
        inputs with shape `(batch, time, channels, ...)`.
        It defaults to the `image_data_format` value found in your
        Keras config file at `~/.keras/keras.json`.
        If you never set it, then it will be `"channels_last"`.
    dilation_rate: An integer or tuple/list of n integers, specifying
        the dilation rate to use for dilated convolution.
        Currently, specifying any `dilation_rate` value != 1 is
        incompatible with specifying any `strides` value != 1.
    activation: Activation function to use
        (see [activations](../activations.md)).
        If you don't specify anything, no activation is applied
        (ie. "linear" activation: `a(x) = x`).
    recurrent_activation: Activation function to use
        for the recurrent step
        (see [activations](../activations.md)).
    use_bias: Boolean, whether the layer uses a bias vector.
    kernel_initializer: Initializer for the `kernel` weights matrix,
        used for the linear transformation of the inputs.
        (see [initializers](../initializers.md)).
    recurrent_initializer: Initializer for the `recurrent_kernel`
        weights matrix,
        used for the linear transformation of the recurrent state.
        (see [initializers](../initializers.md)).
    bias_initializer: Initializer for the bias vector
        (see [initializers](../initializers.md)).
    unit_forget_bias: Boolean.
        If True, add 1 to the bias of the forget gate at initialization.
        Use in combination with `bias_initializer="zeros"`.
        This is recommended in [Jozefowicz et al.]
        (http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf).
    kernel_regularizer: Regularizer function applied to
        the `kernel` weights matrix
        (see [regularizer](../regularizers.md)).
    recurrent_regularizer: Regularizer function applied to
        the `recurrent_kernel` weights matrix
        (see [regularizer](../regularizers.md)).
    bias_regularizer: Regularizer function applied to the bias vector
        (see [regularizer](../regularizers.md)).
    activity_regularizer: Regularizer function applied to
        the output of the layer (its "activation").
        (see [regularizer](../regularizers.md)).
    kernel_constraint: Constraint function applied to
        the `kernel` weights matrix
        (see [constraints](../constraints.md)).
    recurrent_constraint: Constraint function applied to
        the `recurrent_kernel` weights matrix
        (see [constraints](../constraints.md)).
    bias_constraint: Constraint function applied to the bias vector
        (see [constraints](../constraints.md)).
    return_sequences: Boolean. Whether to return the last output
        in the output sequence, or the full sequence.
    go_backwards: Boolean (default False).
        If True, process the input sequence backwards.
    stateful: Boolean (default False). If True, the last state
        for each sample at index i in a batch will be used as initial
        state for the sample of index i in the following batch.
    dropout: Float between 0 and 1.
        Fraction of the units to drop for
        the linear transformation of the inputs.
    recurrent_dropout: Float between 0 and 1.
        Fraction of the units to drop for
        the linear transformation of the recurrent state.

# Input shape
    - if data_format='channels_first'
        6D tensor with shape:
        `(samples, time, channels, rows, cols, vols)`
    - if data_format='channels_last'
        6D tensor with shape:
        `(samples, time, rows, cols, vols, channels)`

# Output shape
    - if `return_sequences`
         - if data_format='channels_first'
            6D tensor with shape:
            `(samples, time, filters, output_row, output_col, output_vol)`
         - if data_format='channels_last'
            6D tensor with shape:
            `(samples, time, output_row, output_col, output_vol, filters)`
    - else
        - if data_format='channels_first'
            5D tensor with shape:
            `(samples, filters, output_row, output_col, output_vol)`
        - if data_format='channels_last'
            5D tensor with shape:
            `(samples, output_row, output_col, output_vol, filters)`
        where o_row and o_col depend on the shape of the filter and
        the padding

# Raises
    ValueError: in case of invalid constructor arguments.

# References
    - [Convolutional LSTM Network: A Machine Learning Approach for
    Precipitation Nowcasting](http://arxiv.org/abs/1506.04214v1)
    The current implementation does not include the feedback loop on the
    cells output
"""

@interfaces.legacy_convlstm2d_support  #not modified
def __init__(self, filters,
             kernel_size,
             strides=(1, 1, 1),
             padding='valid',
             data_format=None,
             dilation_rate=(1, 1, 1),
             activation='tanh',
             recurrent_activation='hard_sigmoid',
             use_bias=True,
             kernel_initializer='glorot_uniform',
             recurrent_initializer='orthogonal',
             bias_initializer='zeros',
             unit_forget_bias=True,
             kernel_regularizer=None,
             recurrent_regularizer=None,
             bias_regularizer=None,
             activity_regularizer=None,
             kernel_constraint=None,
             recurrent_constraint=None,
             bias_constraint=None,
             return_sequences=False,
             go_backwards=False,
             stateful=False,
             dropout=0.,
             recurrent_dropout=0.,
             **kwargs):
    cell = ConvLSTM3DCell(filters=filters,
                          kernel_size=kernel_size,
                          strides=strides,
                          padding=padding,
                          data_format=data_format,
                          dilation_rate=dilation_rate,
                          activation=activation,
                          recurrent_activation=recurrent_activation,
                          use_bias=use_bias,
                          kernel_initializer=kernel_initializer,
                          recurrent_initializer=recurrent_initializer,
                          bias_initializer=bias_initializer,
                          unit_forget_bias=unit_forget_bias,
                          kernel_regularizer=kernel_regularizer,
                          recurrent_regularizer=recurrent_regularizer,
                          bias_regularizer=bias_regularizer,
                          kernel_constraint=kernel_constraint,
                          recurrent_constraint=recurrent_constraint,
                          bias_constraint=bias_constraint,
                          dropout=dropout,
                          recurrent_dropout=recurrent_dropout)
    super(ConvLSTM3D, self).__init__(cell,
                                     return_sequences=return_sequences,
                                     go_backwards=go_backwards,
                                     stateful=stateful,
                                     **kwargs)
    self.activity_regularizer = regularizers.get(activity_regularizer)

def call(self, inputs, mask=None, training=None, initial_state=None):
    return super(ConvLSTM3D, self).call(inputs,
                                        mask=mask,
                                        training=training,
                                        initial_state=initial_state)

@property
def filters(self):
    return self.cell.filters

@property
def kernel_size(self):
    return self.cell.kernel_size

@property
def strides(self):
    return self.cell.strides

@property
def padding(self):
    return self.cell.padding

@property
def data_format(self):
    return self.cell.data_format

@property
def dilation_rate(self):
    return self.cell.dilation_rate

@property
def activation(self):
    return self.cell.activation

@property
def recurrent_activation(self):
    return self.cell.recurrent_activation

@property
def use_bias(self):
    return self.cell.use_bias

@property
def kernel_initializer(self):
    return self.cell.kernel_initializer

@property
def recurrent_initializer(self):
    return self.cell.recurrent_initializer

@property
def bias_initializer(self):
    return self.cell.bias_initializer

@property
def unit_forget_bias(self):
    return self.cell.unit_forget_bias

@property
def kernel_regularizer(self):
    return self.cell.kernel_regularizer

@property
def recurrent_regularizer(self):
    return self.cell.recurrent_regularizer

@property
def bias_regularizer(self):
    return self.cell.bias_regularizer

@property
def kernel_constraint(self):
    return self.cell.kernel_constraint

@property
def recurrent_constraint(self):
    return self.cell.recurrent_constraint

@property
def bias_constraint(self):
    return self.cell.bias_constraint

@property
def dropout(self):
    return self.cell.dropout

@property
def recurrent_dropout(self):
    return self.cell.recurrent_dropout

def get_config(self):
    config = {'filters': self.filters,
              'kernel_size': self.kernel_size,
              'strides': self.strides,
              'padding': self.padding,
              'data_format': self.data_format,
              'dilation_rate': self.dilation_rate,
              'activation': activations.serialize(self.activation),
              'recurrent_activation':
                  activations.serialize(self.recurrent_activation),
              'use_bias': self.use_bias,
              'kernel_initializer':
                  initializers.serialize(self.kernel_initializer),
              'recurrent_initializer':
                  initializers.serialize(self.recurrent_initializer),
              'bias_initializer': initializers.serialize(self.bias_initializer),
              'unit_forget_bias': self.unit_forget_bias,
              'kernel_regularizer':
                  regularizers.serialize(self.kernel_regularizer),
              'recurrent_regularizer':
                  regularizers.serialize(self.recurrent_regularizer),
              'bias_regularizer': regularizers.serialize(self.bias_regularizer),
              'activity_regularizer':
                  regularizers.serialize(self.activity_regularizer),
              'kernel_constraint':
                  constraints.serialize(self.kernel_constraint),
              'recurrent_constraint':
                  constraints.serialize(self.recurrent_constraint),
              'bias_constraint': constraints.serialize(self.bias_constraint),
              'dropout': self.dropout,
              'recurrent_dropout': self.recurrent_dropout}
    base_config = super(ConvLSTM3D, self).get_config()
    del base_config['cell']
    return dict(list(base_config.items()) + list(config.items()))

@classmethod
def from_config(cls, config):
    return cls(**config)

the same problem, how can i contact you


Invalid deploy key

@etienne-dldc @smonteil NPM deploy key doesn't work again - please send me a new one

um... this is annoying, I think we should transfer ownership of the npm package to you so this issue stop happening, @smonteil this should do : https://docs.npmjs.com/cli/owner .

@smonteil Thank you for the token :) I would be thankful for transferring NPM ownership. The repository still will be on the Realytics account :)

I'd just like to second the desire to add @piotr-oles as an owner of fork-ts-checker-webpack-plugin. FWIW, if you're concerned about losing control, it is not necessary to transfer the publishing rights entirely.  You can simply add him as another owner. See the npm docs here:
https://docs.npmjs.com/cli/owner
By way of example, ts-loader has 3 owners.
If you could add @piotr-oles as an owner it would make shipping new versions of the checker a much less difficult experience! 🌻


Remove deprecated API in FDLURLComponents.

Remove deprecated Dynamic Links API for M47.

Please fix the style issue

Fixes #2760


Allowing for EVE flavor boot sequence tweaks in either direction (Xen or KVM)

With the recent switch to KVM as the default hypervisor, we have introduced a small annoyance that it is actually quite difficult (albeit not impossible!) to have a quick knob in grub.cfg in the config partition that would flip a KVM image back to Xen boot sequence.
Note that the reverse has always been the case -- one can simply add set_kvm_boot line to grub.cfg and have Xen image boot in a KVM sequence.
This fix adds an ability to set eve_flavor variable to either xen or kvm as the override.
From now on, an officially supported way to flip a boot sequence is going to be adding the following to grub.cfg:
set_global eve_flavor xen|kvm

However, in order to support legacy deployments that may still have old school direct calls to set_kvm_boot function we're making sure that after such call is made eve_flavor is pointing to the kvm sequence as before.

Added more comments @eriknordmark -- please take a look


chore : Updated gemfile

Description
Updated Gemfile in omnibus
Issues Resolved
Build is now successfully created and tested to all the listed environment
Check List

[ ] New functionality includes tests
[X] All tests pass
[X] All commits have been signed-off for the Developer Certificate of Origin. See https://github.com/chef/chef/blob/master/CONTRIBUTING.md#developer-certification-of-origin-dco

Tests are passed in buildkite.
https://buildkite.com/chef/chef-opscode-pushy-server-master-omnibus-adhoc/builds/74#c997c430-7286-4238-a018-ec4d862dcb79


Support automatic-mixed-precision (AMP)

Hi, I was wondering if this PR is ready to test or not.

Hi, I was wondering if this PR is ready to test or not.

I have tested it locally but it does not seem to improve the speed, so it is still left to open.

Hi, I was wondering if this PR is ready to test or not.

I have tested it locally but it does not seem to improve the speed, so it is still left to open.

I see. Did you try to use model.half() then export using libtorch? I think it should be pure fp16 mode.

Hi, I was wondering if this PR is ready to test or not.

I have tested it locally but it does not seem to improve the speed, so it is still left to open.

I see. Did you try to use model.half() then export using libtorch? I think it should be pure fp16 mode.

No, not yet. I have not tried this approach.


Bouncy Objects

Description
Hi, I have added the following codes:

command for prepare 10 Bowling pins
command for dropping many blocks

How to test

to activate bulk dropper type bulkDrop (your_block_name) (drop_amount)
to activate bowling pin type bowlingPrep (your_block_name)

Finally had a chance to get back to this. Works pretty well, good work!
At the moment the bowling pins don't manage to stay standing, and the command seems to place stuff off to the side. But physics will change soon so maybe we can improve this some more later. I'd also be curious to be able to vary the spread on the bulk drop one day :-)
Thanks @SurajDatta !
I'm merging this via web editor with squash since the commits are a bit messy, then pushing another commit myself with slight tweaks to the help text :-)


Allow ChatGPT Model and Reply in Language to be selected in Picker

I'd like to do it myself, if you don't mind.
I would like to contribute to CopilotForXcode!

Yes please

Released in 0.10.0


Put shake intensity into config.

Thanks! Adding more customizability is definitely on my todo list. I'm a bit busy now but I'll try to take a closer look at this later this week.

Thanks for replying! Btw, I really like the effect of #11, and I'm using his branch now XD. I'm looking forward to your branch merge. :-)

This PR will be included in the 0.4.0 release https://github.com/JoelBesada/activate-power-mode/pull/76. Thank you for your contribution!


Add Person Detection demo for Zephyr RISC-V

This PR ports the Person Detection demo to the Zephyr RISC-V platform.
It has been tested on LiteX SoC with VexRiscv core running on Arty A7 FPGA development board with the Arducam Mini 2MP Plus camera module. Details on building and runinng the demo are included in README.

@petewarden, could you review this?

I'm going to close this PR for now. We will revisit this work as we take a second look at how we want to support TFLM examples across multiple platforms.


XHtmlString no longer supported?

Hi,
did You drop support for XHtmlString?
All properties of that type, are null in Json.  I can`t find a Helper for this type in the code, any clue?

Looks like I accidentally removed it...will add it again ASAP

I've now updated the coded and pushed version 2.9.961 to Nuget.


Support HTTP transport with jaeger.thrift

Fixes #152

Coverage increased (+0.1%) to 85.5% when pulling 02f1b1edce0fa6b7407dc671f726c6e411e1c37a on jaeger-thrift-http into d109b2b5e39041472cd9f187b50f575e9c49b1da on master.

Coverage increased (+0.1%) to 85.5% when pulling 5a836f8cff1c720e93cc2c32ba4197cdfe40d253 on jaeger-thrift-http into d109b2b5e39041472cd9f187b50f575e9c49b1da on master.

Coverage increased (+0.02%) to 85.407% when pulling 15edf6a5759d14fab7fcdd567d6aeb83d8f0eaa2 on jaeger-thrift-http into d109b2b5e39041472cd9f187b50f575e9c49b1da on master.


Comments: focus inputbox after creating a new comment thread

Issue Type: Feature Request
Focus the input box after creating the new comment thread. Right now the focus is still inside the editor.
VS Code version: Code - Insiders 1.44.0-insider (798481c7978af034b054e14ace4e471e7a83f665, 2020-03-16T07:10:59.884Z)
OS version: Darwin x64 19.2.0

This is actually a bug, we do attempt to focus the editor but it failed.
Verifiers:

Clone vscode-extension-samples/comment-sample
Debug
Open a file, click on the gutter to create a new comment thread
The input box in the comment thread should be focused.


added missing --force in example for 'spo app uninstall' command

Closes #6245

Thank you @Saurabh7019!

Merged manually. Thank you!


Requires Windows 10 version 1903 or higher for v0.37

Microsoft PowerToys version
0.37
Running as admin

[ ] Yes

Area(s) with issue?
Installer
Steps to reproduce
Installer quits on Windows 10 Enterprise LTSC 1809 17763.1935
✔ Expected Behavior
Please add support for Windows 10 Enterprise LTSC 1809.
I get that you want to move forward, and don't want to support all the old versions of Windows, but this is really the major Enterprise version...
We will be all stuck on v0.35.
I guess it is at least a year until a new LTSC version of Win10 will be released.
Otherwise, thanks for the great work.
❌ Actual Behavior
Cannot install on Windows 10 LTSC 1809
Other Software
No response

This is something we've been flagging for a while.  Once we get WinUI 3 and can migrate the Settings app, we should be able to migrate back.  Tracked by #6715

I didn't know about it. Great that it is planned.
I suggest you mention that in the future it is planned to come back to older versions of Windows in the release notes, to prevent more people flagging it and spending time on these tickets. Maybe also add a link to the thread with the explanation.
Thanks and keep up the good work, I love powertoys.


Update to Scala 3.0.0-RC3

By the way, it seems there hasn't been a release for Scala 3.0.0-RC2.

Hi @bplommer,
Thank you for your contribution! We really value the time you've taken to put this together.
Before we proceed with reviewing this pull request, please sign the Lightbend Contributors License Agreement:
https://www.lightbend.com/contribute/cla

Hello, while waiting for a new release for 3.0.0-RC2 and RC3, I discover that "scaladex" found "emoji" releases inside of "scala-logging"! Curious...
Otherwise, very happy that this new release will come soon 👍

What is this PR waiting for?

Hello, while waiting for a new release for 3.0.0-RC2 and RC3, I discover that "scaladex" found "emoji" releases inside of "scala-logging"! Curious...

Haha oh no... copy and paste gone awry... fix: https://github.com/lightbend/lightbend-emoji/pull/129


numbat: 1.12.0 -> 1.13.0

Description of changes
https://github.com/sharkdp/numbat/releases/tag/v1.13.0
Things done

Built on platform(s)

[x] x86_64-linux
[ ] aarch64-linux
[ ] x86_64-darwin
[ ] aarch64-darwin

For non-Linux: Is sandboxing enabled in nix.conf? (See Nix manual)

[ ] sandbox = relaxed
[ ] sandbox = true

[x] Tested, as applicable:

NixOS test(s) (look inside nixos/tests)
and/or package tests
or, for functions and "core" functionality, tests in lib/tests or pkgs/test
made sure NixOS tests are linked to the relevant packages

[x] Tested compilation of all packages that depend on this change using nix-shell -p nixpkgs-review --run "nixpkgs-review rev HEAD". Note: all changes have to be committed, also see nixpkgs-review usage
[x] Tested basic functionality of all binary files (usually in ./result/bin/)
24.11 Release Notes (or backporting 23.11 and 24.05 Release notes)

[ ] (Package updates) Added a release notes entry if the change is major or breaking
[ ] (Module updates) Added a release notes entry if the change is significant
[ ] (Module addition) Added a release notes entry if adding a new NixOS module

[x] Fits CONTRIBUTING.md.

Add a :+1: reaction to pull requests you find important.

Result of nixpkgs-review pr 341128 run on x86_64-linux 1

1 package built:

numbat

Looks good to me!

Tests fail on darwin

@donovanglover does the result work in your manual testing? If so we could simply disable checks on darwin for now.

What are we going to do about Darwin?
I think if we don't get feedback from a Darwin user on whether the application works fine with doCheck = false in the next few days, we'll have to mark it as broken.

Approve is regarding patching/in general for linux platforms, will wait on input from darwin contributors/maintainers

@xeals could you set numbat to be broken on darwin? Then we can merge.

Result of nixpkgs-review pr 341128 run on x86_64-linux 1

1 package built:

numbat


"al.enableCodeAnalysis" ignores target:"Internal" in app.json

If "al.enableCodeAnalysis" is set to true in the settings.json the target:"Internal" in app.json is ignored.

I get different warnings that are assuming I want to publish on cloud, e.g. that the ApplicationArea property does not have a value. But I want to publish on-prem.
If I add a code analyzer to the "al.enableCodeAnalysis" it works just fine, e.g.:

AL Language Version: 2.0.56865
Business Central: DE Dynamics NAV 13.1 (25940)

Hi @ArthurSchwarz95! Please read this article and the related ones: https://docs.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/devenv-using-code-analysis-tool . The Internal target and the code analysis do not have any influence on each other. If you want to change a diagnostic, you need to use a ruleset.


Lazy creation of categories

While our create_category_combinations function [1] provides lots of flexiblity in creating categories, it gets quite expensive when adding too many dimensions of categorization.
It might be nice, if instead of always creating all possible combinations of categories, to allow building them only when requested.
For that, it should be sufficient to add the main (parent) categories to our config and the information on how we want to combine them (the groups of categories and the optional functions name_fnand kwargs_fn.
The CategoriesMixin should then be able to check if it is possible to create a category as it is requested and only then add them to the config.
[1] https://github.com/columnflow/columnflow/blob/8cc10e41bd29a226403847a600d4ba2505b71736/columnflow/config_util.py#L337-L446

To quote some numbers: creating a set of 550 categories (106 leafs) takes 5.5 seconds.
Adding one more binary categorization increased the number of categories to 1600 (200 leafs) and the runtime to 953 seconds

Hi @mafrahm , there has been a recent order update which allows the definition of lazy factories for UniqueObjectIndex objects, see the documentation here. I think this should help with this issue, right?

Hi @pkausw, thank you for the suggestion! Apparently the slow part is not creating the categories itself but creating the correct parent-daughter relations between categories, especially this line of code:
https://github.com/columnflow/columnflow/blob/f13aa4584f4403818ade945e2148a129197db05f/columnflow/config_util.py#L479
Changing that line to something like
parent_cat.add_category(name=cat_name, **kwargs)

seems to be significantly faster, but this leads to creating lots of categories with the same name and attributes instead of reusing the same object.
We could also start using lazy factories, but creating the categories itself is rather "cheap" compared to creating the correct dependencies, so it seems that the lazy factories are not able to solve our current performance issues


[BUG] Issue with Deprecation notice Alignment

Describe the bug
There is an issue with Legacy deprecation notice where the Click to Show label & the title are not vertical aligned
To Reproduce
Go to https://min.io/docs/minio/linux/administration/identity-access-management/minio-user-management.html & look for MinIO root user section.
Expected behavior
Text block should be vertical aligned and had equal padding on the top & bottom of the box.
Screenshots

No :yeet-into-sun: emoji, GitHub? I has a sad.

@rushenn if you would be so kind as to look at the CSS/SCSS issue?
@djwfyi @feorlen it's been over 2 years since the deprecation of the legacy root envvars. Objections to simply removing them and any references from our documentation?

Taking a look @ravindk89


Remote-Write relabeling rules partially applied after configuration change and reload

This issue is not easily reproducible - we have many prometheus setups running in this exact configuration fine, and this instance was also running fine until this issue was observed.
Prometheus appears to have only partially applied a remote-write relabelling configuration. The entire config yaml was parsed and loaded (as could be seen from /config), but was missing two relabelling rule applications from the metrics that were remote-written.
We were able to isolate this behaviour because we are running two replicas and the behaviour was identical on both. Restarting replica-1 caused it to correctly apply the relabelling rules for the same configuration, while the other one continued to exhibit the same behaviour. The configuration was confirmed to be identical between both instances, save for the prometheus_replica external label.
Several alterations to the relabelling rules that were not being applied - such as altering the regex to make it more explicit - had no effect on behaviour on the bad replica-0 instance. Eventually removing a large chunk of configuration and re-adding it back seemed to do the trick.
We use the rules as a way to whitelist metrics for remote-write, the general format is as follows:
remote_write:
- url: http://remote-write:7201/api/v1/prom/remote/write
  remote_timeout: 4m
  write_relabel_configs:
  -
  - approx 500 rules total
  -
  - source_labels: [__name__]
    separator: ;
    regex: kep_mpe_uploads_success
    target_label: __mms_ingop
    replacement: streaming/media-processing-platform
    action: replace
  - source_labels: [__name__]
    separator: ;
    regex: onvif_fail_total_count
    target_label: __mms_ingop
    replacement: streaming/media-processing-platform
    action: replace
  - source_labels: [__name__]
    separator: ;
    regex: onvif_success_total_count
    target_label: __mms_ingop
    replacement: streaming/media-processing-platform
    action: replace
  - source_labels: [__mms_ingop]
    separator: ;
    regex: .+
    replacement: $1
    action: keep
  - separator: ;
    regex: __mms_ingop
    replacement: $1
    action: labeldrop
  queue_config:
    capacity: 10000
    max_shards: 10
    min_shards: 2
    max_samples_per_send: 5000
    batch_send_deadline: 30s
    min_backoff: 50ms
    max_backoff: 1s

The inserted configuration was as follows, but were interspersed between other entires:
  - source_labels: [__name__]
    separator: ;
    regex: kep_se_http_requests_total
    target_label: __mms_ingop
    replacement: monitoring/sca-enr
    action: replace
  - source_labels: [__name__]
      separator: ;
      regex: kep_se_queued_messages_total
      target_label: __mms_ingop
      replacement: monitoring/sca-enr
      action: replace
  - source_labels: [__name__]
      separator: ;
      regex: kep_se_queueing_delay_seconds_bucket
      target_label: __mms_ingop
      replacement: monitoring/sca-enr
      action: replace
  - source_labels: [__name__]
      separator: ;
      regex: kep_se_queueing_delay_seconds_count
      target_label: __mms_ingop
      replacement: monitoring/sca-enr
      action: replace
  - source_labels: [cluster_name, __name__]
    separator: ;
    regex: .*sca-enr.*;envoy_cluster_upstream_rq_time_bucket
    target_label: __mms_ingop
    replacement: monitoring/sca-enr
    action: replace
  - source_labels: [cluster_name, __name__]
    separator: ;
    regex: .*sca-enr.*;envoy_cluster_upstream_rq
    target_label: __mms_ingop
    replacement: monitoring/sca-enr

Of these, the envoy_cluster_upstream_rq_time_bucket and envoy_cluster_upstream_rq metrics were not remote-written, while the rest were.
What did you do?

Added 6 entries to prometheus remote-write relabelling configuration
Reloaded prometheus

What did you expect to see?

Entire set of relabelling configurations applied for remote-written metrics

What did you see instead? Under which circumstances?

Only 4 of the 6 entries were applied

Environment

System information:

Linux 5.3.0-59-generic x86_64

Prometheus version:

prometheus, version 2.16.0 (branch: HEAD, revision: b90be6f32a33c03163d700e1452b54454ddce0ec)
  build user:       root@7ea0ae865f12
  build date:       20200213-23:50:02
  go version:       go1.13.8

Timeline:

Time
Observation

2020-06-24T20:21Z
Initial configuration is loaded, only partial results are observed

2020-06-24T20:36Z
Partial metrics are available in remote-written database.

2020-06-24T21:15Z
We start playing with the configuration to try to determine the issue.

2020-06-24T22:40Z
Replica-1 is restarted and we get metrics in remote-written database

2020-06-24T23:23Z
Dropped a large section of configuration

2020-06-24T23:29Z
Added back configuration

2020-06-24T23:30Z
Metrics from replica-0 replicas now available in remote-written db

Logs:

The behaviour of the WAL watcher seems suspicious here, I would expect to see more occurrences during other reloads, since at least one contained changes to the relabelling rules.
{"caller":"head.go:731","component":"tsdb","duration":"3.766783368s","first":522,"last":524,"level":"info","msg":"WAL checkpoint complete","ts":"2020-06-24T19:00:14.677Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T20:21:33.017Z"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T20:21:33.299Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T20:23:01.318Z"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"Stopping remote storage...","remote_name":"aff0cf","ts":"2020-06-24T20:23:01.354Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"WAL watcher stopped","queue":"aff0cf","remote_name":"aff0cf","ts":"2020-06-24T20:23:02.863Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"Remote storage stopped.","remote_name":"aff0cf","ts":"2020-06-24T20:23:02.962Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"starting WAL watcher","queue":"1645c0","remote_name":"1645c0","ts":"2020-06-24T20:23:02.962Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"replaying WAL","queue":"1645c0","remote_name":"1645c0","ts":"2020-06-24T20:23:02.962Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T20:23:03.201Z"}
{"caller":"dedupe.go:112","component":"remote","duration":"1m55.599243324s","level":"info","msg":"done replaying WAL","remote_name":"1645c0","ts":"2020-06-24T20:24:58.562Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T20:48:36.049Z"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T20:48:36.315Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T20:50:01.485Z"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T20:50:02.172Z"}
{"caller":"compact.go:496","component":"tsdb","duration":"8.866740271s","level":"info","maxt":1593028800000,"mint":1593021600000,"msg":"write block","ts":"2020-06-24T21:00:09.029Z","ulid":"01EBM22Q92JXPWG63JFXFYSNDY"}
{"caller":"head.go:661","component":"tsdb","duration":"391.516337ms","level":"info","msg":"head GC completed","ts":"2020-06-24T21:00:10.399Z"}
{"caller":"head.go:731","component":"tsdb","duration":"3.9312373s","first":525,"last":527,"level":"info","msg":"WAL checkpoint complete","ts":"2020-06-24T21:00:14.330Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T22:29:01.318Z"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T22:29:01.609Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T22:32:01.319Z"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T22:32:01.611Z"}
{"caller":"compact.go:496","component":"tsdb","duration":"9.265954394s","level":"info","maxt":1593036000000,"mint":1593028800000,"msg":"write block","ts":"2020-06-24T23:00:09.427Z","ulid":"01EBM8YEH1RYFRGEW7SG8V0X1D"}
{"caller":"head.go:661","component":"tsdb","duration":"411.745914ms","level":"info","msg":"head GC completed","ts":"2020-06-24T23:00:11.002Z"}
{"caller":"head.go:731","component":"tsdb","duration":"3.733722625s","first":528,"last":530,"level":"info","msg":"WAL checkpoint complete","ts":"2020-06-24T23:00:14.736Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T23:23:01.318Z"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"Stopping remote storage...","remote_name":"1645c0","ts":"2020-06-24T23:23:01.354Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"WAL watcher stopped","queue":"1645c0","remote_name":"1645c0","ts":"2020-06-24T23:23:02.059Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"Remote storage stopped.","remote_name":"1645c0","ts":"2020-06-24T23:23:02.122Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"starting WAL watcher","queue":"a7f4af","remote_name":"a7f4af","ts":"2020-06-24T23:23:02.123Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"replaying WAL","queue":"a7f4af","remote_name":"a7f4af","ts":"2020-06-24T23:23:02.123Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T23:23:02.362Z"}
{"caller":"dedupe.go:112","component":"remote","duration":"1m43.78021913s","level":"info","msg":"done replaying WAL","remote_name":"a7f4af","ts":"2020-06-24T23:24:45.903Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-24T23:29:01.318Z"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"Stopping remote storage...","remote_name":"a7f4af","ts":"2020-06-24T23:29:01.362Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"WAL watcher stopped","queue":"a7f4af","remote_name":"a7f4af","ts":"2020-06-24T23:29:02.869Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"Remote storage stopped.","remote_name":"a7f4af","ts":"2020-06-24T23:29:02.933Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"starting WAL watcher","queue":"1645c0","remote_name":"1645c0","ts":"2020-06-24T23:29:02.934Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"dedupe.go:112","component":"remote","level":"info","msg":"replaying WAL","queue":"1645c0","remote_name":"1645c0","ts":"2020-06-24T23:29:02.934Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-24T23:29:03.981Z"}
{"caller":"dedupe.go:112","component":"remote","duration":"1m50.384327977s","level":"info","msg":"done replaying WAL","remote_name":"1645c0","ts":"2020-06-24T23:30:53.318Z","url":"http://remote-write:7201/api/v1/prom/remote/write"}
{"caller":"compact.go:496","component":"tsdb","duration":"8.659843152s","level":"info","maxt":1593043200000,"mint":1593036000000,"msg":"write block","ts":"2020-06-25T01:00:08.821Z","ulid":"01EBMFT5S1ARMVFJ4ZRBDNZPEZ"}
{"caller":"head.go:661","component":"tsdb","duration":"325.401756ms","level":"info","msg":"head GC completed","ts":"2020-06-25T01:00:10.105Z"}
{"caller":"head.go:731","component":"tsdb","duration":"3.826068766s","first":531,"last":533,"level":"info","msg":"WAL checkpoint complete","ts":"2020-06-25T01:00:13.931Z"}
{"caller":"main.go:747","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Loading configuration file","ts":"2020-06-25T02:27:04.054Z"}
{"caller":"main.go:775","filename":"/etc/prometheus/config_out/prometheus.env.yaml","level":"info","msg":"Completed loading of configuration file","ts":"2020-06-25T02:27:04.331Z"}

Hmm, those logs indicate that there was no change to the remote write configuration for the 2020-06-24T20:21:33.017Z reload, rather that 2020-06-24T20:23:01.318Z is where that happened. Can you double-check your timeline?
I'm not seeing anywhere in the code where we mutate the remote write relabel configs after first parsing them.

Hmm, those logs indicate that there was no change to the remote write configuration for the 2020-06-24T20:21:33.017Z reload, rather that 2020-06-24T20:23:01.318Z is where that happened. Can you double-check your timeline?

You may very well be correct here, the timeline I have is from a configuration change that is then propagated out, so it is likely there is a delay of a few mins and the change happens at 2020-06-24T20:23:01.318Z as you say.

I think this issue is the same as what was fixed in https://github.com/prometheus/prometheus/pull/7073. Would you be able to upgrade to the 2.18.X line of releases and see if you can still reproduce the issue? I would not recommend updating to 2.19.X yet as there is a bug causing a panic in some remote write reloads right now.

Thanks for the quick response! We have started a rollout to 2.19.1 already. If the potential fix is there, then we shouldn't encounter this again considering how rare this seems to be.
Will open another issue if we see this happen on a release later than what you suggest.


solved chapter1 - exercise 1

made class BMI Calculator
made method bmi-calculator
made method calculate

Moment, this is the wrong code. This is exercise 2 or 3 not exercise 1
Schould I make a new PR for exercise 1 or make a new commit on this PR


CallingExternal services directly - “global.proxy.includeIPRanges” OR “includeOutboundIpRanges”

Is your feature request related to a problem? Please describe.
I want to access external services directly, In the documentation there is a mention of "global.proxy.includeIPRanges" but that is deprecated.
The new closest thing I could find is "includeOutboundIpRanges" in sidecar-injector pod's Config-Map.
I am not sure how to use "includeOutboundIpRanges":

using annotations in target deployment yamls ?
editing config-map by adding exernal IPs somehwere (but where) ? (I AM NOT USING HELM FOR INSTALLATION)

or is there any other way to achieve "Calling External services directly". I have read about oprions like --configlist but couldnt find a way to use this switch, in which command to use this. Can someone please point me to the detailed example if this is the right way to access external services.
Describe the solution you'd like
Please update the documentation to know how can we achieve this.
Describe alternatives you've considered
I've considered creating serviceentry but those are also failing, following are the Yamls I used for service entry:
For Redis Pod:
kind: ServiceEntry
metadata:
  name: redis-egress
  namespace: webui-istio
spec:
  hosts:
  - 'redis-sentinel.redis.svc.cluster.local'
  location: MESH_EXTERNAL
  ports:
  - number: 26379
    name: http
    protocol: HTTP
  resolution: DNS

I tried reaching out to MongoDB VM using serviceentry that too without any success, I used following servieentry config:
kind: ServiceEntry
metadata:
  name: external-svc-mongocluster
  namespace: Application2-istio
spec:
  hosts:
  - mymongodb.somedomain # not used
  addresses:
  - <IP_ADDRESS>/25 # VIPs
  ports:
  - number: 27020
    name: mongodb
    protocol: MONGO
  location: MESH_EXTERNAL
  resolution: STATIC
  endpoints:
  - address: <IP_ADDRESS>

Additional context
Using istio 0.8, istio-demo.yaml, without using HELM.

Would you be able to try 1.0? Using ServiceEntries is the recommended solution and your configs looks correct. Our handling of subnets in the addresses field was problematic in 0.8.


Add cursor style support

Hello!
Thank you for this plugin.
I've found that the current version does not support cursor style. I added this functionality as it is necessary in my project.

thanks

https://bl.ocks.org/lsbardel/b1133566e01d6d45fa7d11523dcb3e70


Update cqlsh_test index ordering after 2.2 driver update

Depends on https://issues.apache.org/jira/browse/CASSANDRA-10513

The code looks good. Ping us when CASSANDRA-10513 is resolved and we can merge this.

Committed CASSANDRA-10513 and merged the PR.

:+1: Thanks!


Add Demo in Documentation

if it's possible. Can you add a working demo of the carousel so that we can have an overview of the component before using. Thanks!

Sure, I am working on updating the docs


Fix unknown probe-args guidance for none -> smallest-probes change

Update guidance in error message to list smallest-probes instead of none which no longer exists.
#855 changed --probe-args=none to --probe-args=smallest-probes, but the error message for unknown --probe-args arguments still lists none as a valid argument (which is especially confusing when using --probe-args=none results in guidance suggesting to use none).

Integration test failure looks unrelated to change under test.


Use GET instead of POST where appropriate

Probably:

GetHome
ListFolder
...

should use a GET verb instead of POST when contacting our nextcloud app

maybe just all the ones that start with 'Get..' or 'List...' so:

GetMD
GetPathByID
ListFolder
ListGrants
ListRecycle
ListRevisions

and then also use the query string instead of the body

Will leave them as POST for to keep things simple, but leave this ticket open so we can fix it some time in the future


⚠ ClamAV has degraded performance

In d18aba0, ClamAV (https://spamassassin.apache.org/) experienced degraded performance:

HTTP code: 200
Response time: 448 ms

Resolved: ClamAV performance has improved in 0d044f0 after 21 minutes.


moved appropriate dependencies to dev dependencies

moved dependencies which are only required while testing and development and not in runtime to dev dependencies
dependencies which are moved:

These are indeed runtime dependencies.

@trxcllnt These only appear to be runtime dependencies of the example cli application, not the library. Most consumers of 'apache-arrow' are using it as a library, and this brings in a lot of additional unnecessary dependencies.
https://github.com/apache/arrow/issues/42147
I did a bit of inspection, and the only dependency of the library apache-arrow is flatbuffers. If nothing else, the example cli application should be it's own package with it's own dependencies so users arent forced to import said dependencies.

Actually, seems like it's only 2.9MB and the biggest one is @types/node
cost-of-modules

Making sure dependencies are installed
npm install --production

npm warn config production Use `--omit=dev` instead.

changed 3 packages in 4s

Calculating...

┌───────────────────────────┬────────────┬───────┐
│ name                      │ children   │ size  │
├───────────────────────────┼────────────┼───────┤
│ @types/node               │ 0          │ 1.99M │
├───────────────────────────┼────────────┼───────┤
│ flatbuffers               │ 0          │ 0.27M │
├───────────────────────────┼────────────┼───────┤
│ @swc/helpers              │ 0          │ 0.22M │
├───────────────────────────┼────────────┼───────┤
│ command-line-args         │ 0          │ 0.13M │
├───────────────────────────┼────────────┼───────┤
│ command-line-usage        │ 0          │ 0.13M │
├───────────────────────────┼────────────┼───────┤
│ tslib                     │ 0          │ 0.08M │
├───────────────────────────┼────────────┼───────┤
│ json-bignum               │ 0          │ 0.02M │
├───────────────────────────┼────────────┼───────┤
│ @types/command-line-usage │ 0          │ 0.01M │
├───────────────────────────┼────────────┼───────┤
│ @types/command-line-args  │ 0          │ 0.00M │
├───────────────────────────┼────────────┼───────┤
│ 9 modules                 │ 0 children │ 2.86M │
└───────────────────────────┴────────────┴───────┘

Even if the impact is relatively small, there is no good reason for them to be there for consumers of the 'apache-arrow' library.  I think it's worth the effort to either refactor, or make them into dev dependencies.

I think we would have a breaking change when we remove the CLI from the public API. I am okay with that and would be happy to review a pull request.


Memory Issues when opening files.

There have been problems reported when opening Excel files like this one from Freedom House.
Code that causes the memory growth (roo-1.13.2):
require 'roo'
require 'uri'  # Needed to prevent a NameError on URI

# Where the xls is a renamed copy of the mentioned sheet ...
sheet = Roo::Spreadsheet.open('freedomhouse-press.xls')

See:
https://github.com/roo-rb/roo/issues/179
https://github.com/roo-rb/roo/issues/168

Hi @stevendaniels thanks for your work, I was wondering if you figured out something related this leak because I'm affected by it.

duplicate of issues in roo base


[Feature] Add FeedbackBlock

For DIC

There are some other locations using tuple in torch.cat (Lines 92, 106)

echos kelvin. Please rename ".first" and ".last" to other names. This has happend multiple times. They are not good names.


Soften Profile inheritence rules

In some cases, such as Workflow Run Crate there are multiple profiles that are related with inheritance.
There are also less strict inheritance profiles such as https://trefx.uk/trusted-wfrun-crate/0.3/
This section now makes it softer how to list multiple profiles, they are suggestions rather than enforcing any hierarchy.

Didn't we decide to remove all this from 1.2? @stain

This needs to be moved to a different document, right?

Remove inheritance, at best "referenced/suggested" profiles.

Decision 2024-04-11: Not do formal inheritance system at RO-Crate level yet before we have tried out how it works with actual implementations (e.g. SHACL, Crate-O modes) -- then facilitate them.

I have finally managed to tidy up the profile section.
Changes:

Merged to latest master (but pending #296 with retrieval section moved out from here)
Use only rdfs:Class and rdf:Property, documented as Schema.org style schemas
Inheritance across profiles now only "Multiple Profiles" as suggestions of conformance only
Renamed section "Shared contextual entities from a Profile Crate"
Examples expanded following @simleo's suggestion

Suggestion in call 2024-04-25 @CaroleGoble was to also look at Delegation pattern:

https://en.wikipedia.org/wiki/Delegation_pattern
https://refactoring.guru/replace-delegation-with-inheritance
https://stackoverflow.com/questions/832536/when-to-use-delegation-instead-of-inheritance
https://www.jetbrains.com/help/idea/replace-inheritance-with-delegation.html

In a sense we use delegation pattern in https://trefx.uk/5s-crate/0.4/#referencing-a-workflow-crate as instead of subclassing Workflow RO-Crate, it references the Workflow RO-Crate by URL -- one crate to another.   I've documented this pattern in #296.
This would make the resulting 5s-crate as Workflow Run Crate not conform to any strict inheritance rules, as it would not have the usual ComputationalWorkflow etc. and so should not itself declare conformsTo the Workflow RO-Crate  (which we would have to then make Workflow RO-Crate indirection also be a workflow language!).
Note a side issue: at the moment that 5s-crate is in that case purposefully ignoring the MUST of conformsTo requirements -- we can argue over that separately!

@simleo Good to go..?

@simleo Good to go..?

AFAICT, yes


DocsArchive-<IP_ADDRESS>Auto archive content

Please don't merge this PR until target archive repo PR https://github.com/OPS-E2E-PPE/docs-archive-test-target_584ef204-3adf-4927-afde-7e24225366fa/pull/1 is merged into live branch.
Auto archive content to https://github.com/opstest2/docs-archive-test-target_584ef204-3adf-4927-afde-7e24225366fa.git

Docs Build status updates of commit 8780905:
:x: Validation status: errors
Please follow instructions here which may help to resolve issue.

File
Status
Preview URL
Details

:x:Error

Details

[Error-RuningBuildFailed] Some unexpected errors happened when running build, please open a ticket in https://aka.ms/SiteHelp and include the error report for our team to troubleshoot

For more details, please refer to the build report.
If you see build warnings/errors with permission issues, it might be due to single sign-on (SSO) enabled on Microsoft's GitHub organizations. Please follow instructions here to re-authorize your GitHub account to Docs Build.
Note: Broken links written as relative paths are included in the above build report. For broken links written as absolute paths or external URLs, see the broken link report.
Note: Your PR may contain errors or warnings unrelated to the files you changed. This happens when external dependencies like GitHub alias, Microsoft alias, cross repo links are updated. Please use these instructions to resolve them.
For any questions, please:Try searching the docs.microsoft.com contributor guidesPost your question in the Docs support channel


AKTable slowdown fix

Dude, I saw this PR Title and thought it was just the AKTable fix.  Quite a few deletions in there too, very cool.


Add license

I added a license to the init.py file

@srobins259 I can't merge this into master because it's based on exploratory and we're not ready to roll that out yet.


problem with change files name in work path in new version nexrender and don't work action-encode input

i wan to add pre-render action to do encode video file in work path  but when i set input and output encode i think don't work
this is my postrender action in json :
"assets": [   {      "src": "[https://dl.viditor.net/uploads/users/93701_b209470a3db39ee3a0c5fa2e8fb166ee/userProjects/4752_flyermotion-white/350599/1080x1920-6745e9fde9aa4.mp4](https://l.ble.ir/?l=https%3A%2F%2Fdl.viditor.net%2Fuploads%2Fusers%2F93701_b209470a3db39ee3a0c5fa2e8fb166ee%2FuserProjects%2F4752_flyermotion-white%2F350599%2F1080x1920-6745e9fde9aa4.mp4&spec=eyJzcCI6IjE5NDc3MDQxMTAiLCJjcCI6IjE5NDc3MDQxMTAifQ%3D%3D)",      "type": "video",      "layerName": "mediaHolder_02.mp4",      "composition": "media02"    }],"actions": {    "prerender": [      {        "module": "@nexrender/action-encode",        "input": "1080x1920-6745e3e1b8331.mp4",        "output": "copy_1080x1920-6745e3e1b8331.mp4",        "params": {          "-ss": "0",          "-to": "4.3263012354489",          "-acodec": "aac",          "-ab": "128k",          "-ar": "44100",          "-vcodec": "libx264",          "-r": "25"        }      },
this is my error :

this problem not in older version , i think this error maybe in new version action encode or downloading file with add unique name like in image , how to fix? you have any option to dont do add unique title in first name of files in work path ?
please help what to do ?

this is because add this line in
packages/nexrender-core/src/tasks/download.js
in new version add this line to add random name
if comment maybe work
` /* if asset doesnt have a file name, make up a random one /
if (protocol === 'data' && !asset.layerName) {
destName = Math.random().toString(36).substring(2);
} else {
destName = path.basename(asset.src)
destName = destName.indexOf('?') !== -1 ? destName.slice(0, destName.indexOf('?')) : destName;
/ ^ remove possible query search string params ^ /
destName = decodeURI(destName) / < remove/decode any special URI symbols within filename */
    /* prevent duplicate filename collisions during parallel fetch */
    if (!asset.sequence) {
        destName = Math.random().toString(36).substring(2) + '-' + destName;
    }
}`

 @inlife

can you add option in actions or action-encode to when we use input , can find new file name in input in relative path workpath and do
like this :
in assets
{
"type": "video",      "layerName": "mediaHolder_02.mp4",      "composition": "media02",
"src": "[...........93701_b209470a3db39ee3a0c5fa2e8fb166ee/userProjects/4752_flyermotion-white/350599/1080x1920-6745e9fde9aa4.mp4
}
in action encode
like when we add assets in action encode input
"input": "1080x1920-6745e3e1b8331.mp4"
action can find assets with new name and can do action
"input": "dawr312131jkadd-1080x1920-6745e3e1b8331.mp4"
and or have feature in assets we can add params
{
"type": "video",
"layerName": "mediaHolder_02.mp4",
"composition": "media02",
"src": "[............../93701_b209470a3db39ee3a0c5fa2e8fb166ee/userProjects/4752_flyermotion-white/350599/1080x1920-6745e9fde9aa4.mp4]"
"params": {  "-ss": "0",          "-to": "4.3263012354489"}
}
that auto use action encode to trim video automaticaly


Where is pGlycoRes file in pGlyco3?

I want to use gGlyco3 to generate site localization, but I encounter two problems in the software; 1. I don't have pGlycoRes files at spectrum. Whether this is because it is HCD mode. 2. I do not see the run button, how to run the file after filling it?

pGlycoRes must be an item in gLabel, what you need is pGlycoGUI.exe, not gLabel.


Why do we have to pass data two times?

During initialization flowMC.Sampler asks for data that will be passed to the logpdf, flowMC.Sampler.sample method also asks for data that will be passed to the logpdf. Are they same or different, and if they are same then why should we pass it two time?

The first declaration of data is used in pre-compilation if it is turned on. It might be removed in the future as we search for more ergonomic design


migration: generate empty isos on target for cloud-inits, configmaps, secrets, ...

What this PR does / why we need it:
On migration, libvirt expects to find isos on the target of the exact same size as they are on the source.
Before this PR, it is not always the case, as we trust that xorrisofs will produce the right size iso, which may not be the case.
This PR adds a VMI status field to keep track of the iso sizes, and creates blank files of the right size on the target.
It does so for cloud-inits, configmaps, secrets, downwardapis, service-accounts and syspreps.
Which issue(s) this PR fixes (optional, in fixes #<issue number>(, fixes #<issue_number>, ...) format, will close the issue(s) when PR gets merged):
Fixes https://bugzilla.redhat.com/show_bug.cgi?id=2008511
Special notes for your reviewer:
This PR solves the same problem as https://github.com/kubevirt/kubevirt/pull/6475 but in a completely different way.
Release note:

VMs with cloud-init data should now properly migrate from older KubeVirt versions

/cc @vladikr
/cc @rmohr
/cc @stu-gott
/cherrypick release-0.41
/cherrypick release-0.44

/retest

/test pull-kubevirt-check-tests-for-flakes

/retest

/retest

It all looks great to me, only one last request.

@vladikr @jean-edouard did it turn out that we do not have to consider this for configmaps and secrets?

It all looks great to me, only one last request.

@vladikr @jean-edouard did it turn out that we do not have to consider this for configmaps and secrets?

This PR is now handling configmaps and secrets (and downwardapi and service-account and sysprep). I should probably adjust the PR description.

This PR is now handling configmaps and secrets (and downwardapi and service-account and sysprep). I should probably adjust the PR description.

I see now. Thanks.

/retest

Thanks! Great work!
/approve

/cherrypick release-0.44
Doesn't look like the bot acknowledged this one

/retest


Extract dependencies to Dependencies

Test run finished after 415315 ms
[       261 containers found      ]
[         2 containers skipped    ]
[       259 containers started    ]
[         0 containers aborted    ]
[       258 containers successful ]
[         1 containers failed     ]
[      2608 tests found           ]
[       111 tests skipped         ]
[      2497 tests started         ]
[        27 tests aborted         ]
[      2467 tests successful      ]
[         3 tests failed          ]
##[error]Process completed with exit code 255.

The following dependencies have later milestone versions:

biz.aQute.bnd:biz.aQute.bnd.gradle [5.1.2 -> 5.3.0]
https://bnd.bndtools.org/
biz.aQute.bnd:biz.aQute.resolve [5.1.2 -> 5.3.0]
https://bnd.bndtools.org/
com.diffplug.spotless:com.diffplug.spotless.gradle.plugin [5.1.2 -> 5.14.2]
com.github.jnr:jnr-unixsocket [0.28 -> 0.38.8]
http://github.com/jnr/jnr-unixsocket
com.puppycrawl.tools:checkstyle [8.28 -> 8.44]
https://checkstyle.org/
info.picocli:picocli [4.5.1 -> 4.6.1]
http://picocli.info
info.picocli:picocli-codegen [4.5.1 -> 4.6.1]
http://picocli.info
net.ltgt.errorprone:net.ltgt.errorprone.gradle.plugin [1.2.1 -> 2.0.2]
org.apache.httpcomponents.client5:httpclient5 [5.0 -> 5.1]
https://hc.apache.org/httpcomponents-client-5.0.x/${project.version}/
org.assertj:assertj-core [3.15.0 -> 3.20.2]
https://assertj.github.io/doc/
org.bouncycastle:bcpkix-jdk15to18 [1.68 -> 1.69]
http://www.bouncycastle.org/java.html
org.bouncycastle:bcprov-jdk15to18 [1.68 -> 1.69]
http://www.bouncycastle.org/java.html
org.bouncycastle:bctls-jdk15to18 [1.68 -> 1.69]
http://www.bouncycastle.org/java.html
org.codehaus.mojo:animal-sniffer-annotations [1.19 -> 1.20]
http://www.mojohaus.org/animal-sniffer
org.eclipse.jetty:jetty-client [9.4.27.v20200227 -> 11.0.6]
https://eclipse.org/jetty
org.eclipse.platform:org.eclipse.osgi [3.16.0 -> 3.16.300]
http://www.eclipse.org/platform
org.hamcrest:hamcrest-library [2.1 -> 2.2]
http://hamcrest.org/JavaHamcrest/
org.jetbrains.dokka:dokka-gradle-plugin [0.10.1 -> 1.5.0]
https://github.com/Kotlin/dokka
org.jsoup:jsoup [1.13.1 -> 1.14.1]
https://jsoup.org/
org.junit.jupiter:junit-jupiter-api [5.7.0 -> 5.7.2]
https://junit.org/junit5/
org.junit.jupiter:junit-jupiter-engine [5.7.0 -> 5.7.2]
https://junit.org/junit5/
org.junit.jupiter:junit-jupiter-params [5.7.0 -> 5.7.2]
https://junit.org/junit5/
org.junit.vintage:junit-vintage-engine [5.7.0 -> 5.7.2]
https://junit.org/junit5/
org.openjsse:openjsse [1.1.6 -> 1.1.7]
http://openjsse.github.io/openjsse/
software.amazon.cryptools:AmazonCorrettoCryptoProvider [1.3.1 -> 1.6.1]
https://github.com/corretto/amazon-corretto-crypto-provider

And I never see the use of spotless and errorprone plugins now, if them could be removed
plugins {
  id "ru.vyarus.animalsniffer" version "1.5.3"
  id "me.champeau.gradle.japicmp" version "0.2.9"
  id "com.diffplug.spotless" version "5.1.2"
  id "net.ltgt.errorprone" version "1.2.1"
}

Some of the dependency updates will be non-trivial.  Like Dokka.


ButtonGroup: The pseudo class ":first-child" is potentially unsafe when doing server-side rendering. Try changing it to ":first-of-type"

Describe the bug
ButtonGroup gives this error:

To Reproduce
Steps to reproduce the behavior:

Go to the ButtonGroup styleguide or docs site
Open the console
This also appears in unit tests

Expected behavior
No error or warning exists.
Additional context
We'll need to rethink how we style ButtonGroup as ":first-of-type" is not equivalent to ":first-child". This ticket is to figure out if there's a workaround to this while keeping the same styles.

This is super annoying and every one of our adopters gets this warning in their console. The downside is that it's not a straightforward fix 🙃

This is related to the version of Storybook we are on. Could potentially be addressed when we look at #1064.

This error appears not only in the ButtonGroup component. Every component with argTypes prop has this problem. This issue happens because our version of storybook is quite old and we need to upgrade it from 6.5.10 to 7+. They actually fixed this problem in later versions: https://github.com/storybookjs/storybook/issues/18103 -> https://github.com/storybookjs/storybook/issues/20730.