Use with ForwardDiff

I was trying to use this with ForwardDiff, but not an array of structs like #19, just using dual numbers within a loop and then extracting ordinary numbers. Something like this:
dA = ForwardDiff.Dual(0.0, (1.0, 0.0))
dB = ForwardDiff.Dual(0.0, (0.0, 1.0))
for i in axes(A,1)
    tmp = (A[i] + dA) * log(B[i] + dB)
    C[i] = ForwardDiff.partials(tmp, 1)
...

I got this to run with @avx on the loop, by filling in whatever methods were missing, such as:
function Base.:+(x::Dual{Z,T,D}, sv::SVec{N}) where {Z,T<:Number,D,N}
    duals = ntuple(n -> +(x, sv[n]), N)
    Dual(svec(val.(duals)), ntuple(d -> svec(partials.(duals, d)), D))
end

@inline val(d::Dual) = d.value
@inline svec(tup::NTuple{N,T}) where {N,T} = SVec{N,T}(tup...)

However the result is slower than without, and has many more allocations.
I wonder whether this is expected to work, and whether adding methods like this is right thing to do? I can tidy up an example if there isn't an obvious fatal flaw here.

The README also has an example with complex numbers.
Mind posting all the code for a reproducable example? It sounds like you're taking the right approach.
Allocations suggests there may be a type instability somewhere.
Or perhaps a method (possibly in my code) defined with excess parameters in the where, e.g. foo(a) where {T}. I wish that threw an error, instead of running slowly and allocating memory.

OK, I think I see what you mean about keeping things as struct-of-SVecs, and a few definitions like this appear to be enough:
function Base.:+(x::Dual{Z,T,D}, sv::SVec{N,S}) where {Z,T,D,N,S}
    y = x.value + sv
    ps = ntuple(d -> partials(x,d) + zero(sv), Val(D))
    Dual{Z,typeof(y),D}(y, Partials{D,typeof(y)}(ps))
end

@code_warntype is happy with that, but speed is improved by being a bit more cautious and avoiding typeof(y), current attempt is take 4 here.
The example in which I was timing things is now here, not so minimal!
I start to think that the problem is things like ForwardDiff.partials(tmp, 1). Commenting these out (ideally leaving C[j] = dC[j] + one(T)) speeds things up greatly. I tried writing instead tmp.partials.values[1] but then got errors from @avx. Likewise unroll=1 seems to cause errors on the gradient. Perhaps also strangely, I need using ForwardDiff: partials for things to work (only with @avx) which seems like some strange scope issue?

Looking at those benchmarks, there are a lot of allocations when using @avx, but not otherwise.
Could you by any chance try and find out where they're coming from?

Perhaps also strangely, I need using ForwardDiff: partials for things to work (only with @avx) which seems like some strange scope issue?

Is that because of:
function Base.:+(x::Dual{Z,T,D}, sv::SVec{N,S}) where {Z,T,D,N,S}
    y = x.value + sv
    ps = ntuple(d -> partials(x,d) + zero(sv), Val(D))
    Dual{Z,typeof(y),D}(y, Partials{D,typeof(y)}(ps))
end

?
Or, would similar code (not involving SVec) work? partials isn't normally exported, because ForwardDiff doesn't export anything.

Re ForwardDiff: partials, that is in scope where I define these methods for + etc, although the latest version uses x.partials.values[d] instead of the function. But inside the @avx loop I had to keep the function, and the macro defines it $ForwardDiff.partials(x, $d), which is enough for the non-avx loop to see it.
Weirdly, after fiddling with seemingly unrelated things since then, this scope issue has gone away for code made by the macro. But persists in the ∇apply!109 function I copied into that file. And they have very different numbers of allocations, although both are slow:
julia> @btime Tracker.gradient(sum∘unfill∘f_fwd_avx, $A, $B, $C); # newer macro's code
  2.448 ms (89 allocations: 2.47 MiB)

julia> @btime Tracker.gradient(sum∘unfill∘create109, $A, $B, $C); # won't run without using ForwardDiff: partials
  2.754 ms (180065 allocations: 18.03 MiB)

In ∇apply!109 there are some attempts to avoid this function by writing ℛℰ𝒮.partials[3] etc, all of which errors from @avx. Is getfield expected to work?

Yes, that's definitely a problem with @avx:
julia> @macroexpand @avx for i = 📏i
           for j = 📏j
               ℛℰ𝒮 = (A[i] + 𝜀A) * log((B[i, j] + 𝜀B) / (C[j] + 𝜀C))
               𝛥B[i, j] = 𝛥B[i, j] + (ForwardDiff).partials(ℛℰ𝒮, 1) * 𝛥ℛℰ𝒮[i]
               𝛥C[j] = 𝛥C[j] + (ForwardDiff).partials(ℛℰ𝒮, 2) * 𝛥ℛℰ𝒮[i]
               𝛥A[i] = 𝛥A[i] + (ForwardDiff).partials(ℛℰ𝒮, 3) * 𝛥ℛℰ𝒮[i]
           end
       end
quote
    var"##loopi#298" = LoopVectorization.maybestaticrange(📏i)
    var"##i_loop_lower_bound#299" = LoopVectorization.maybestaticfirst(var"##loopi#298")
    var"##i_loop_upper_bound#300" = LoopVectorization.maybestaticlast(var"##loopi#298")
    var"##loopj#301" = LoopVectorization.maybestaticrange(📏j)
    var"##j_loop_lower_bound#302" = LoopVectorization.maybestaticfirst(var"##loopj#301")
    var"##j_loop_upper_bound#303" = LoopVectorization.maybestaticlast(var"##loopj#301")
    var"##vptr##_A" = LoopVectorization.stridedpointer(A)
    var"##vptr##_B" = LoopVectorization.stridedpointer(B)
    var"##vptr##_C" = LoopVectorization.stridedpointer(C)
    var"##vptr##_𝛥B" = LoopVectorization.stridedpointer(𝛥B)
    var"##vptr##_𝛥ℛℰ𝒮" = LoopVectorization.stridedpointer(𝛥ℛℰ𝒮)
    var"##vptr##_𝛥C" = LoopVectorization.stridedpointer(𝛥C)
    var"##vptr##_𝛥A" = LoopVectorization.stridedpointer(𝛥A)
    begin
        $(Expr(:gc_preserve, :(LoopVectorization._avx_!(Val{(0, 0)}(), Tuple{:LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x01, 0x01), :LoopVectorization, :LOOPCONSTANTINSTRUCTION, LoopVectorization.OperationStruct(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x02), :LoopVectorization, :+, LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000102, LoopVectorization.compute, 0x00, 0x03), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x02, 0x04), :LoopVectorization, :LOOPCONSTANTINSTRUCTION, LoopVectorization.OperationStruct(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x05), :LoopVectorization, :+, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000405, LoopVectorization.compute, 0x00, 0x06), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000002, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x03, 0x07), :LoopVectorization, :LOOPCONSTANTINSTRUCTION, LoopVectorization.OperationStruct(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x08), :LoopVectorization, :+, LoopVectorization.OperationStruct(0x0000000000000002, 0x0000000000000000, 0x0000000000000000, 0x0000000000000708, LoopVectorization.compute, 0x00, 0x09), :LoopVectorization, :/, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000609, LoopVectorization.compute, 0x00, 0x0a), :LoopVectorization, :log, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x000000000000000a, LoopVectorization.compute, 0x00, 0x0b), :LoopVectorization, :*, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x000000000000030b, LoopVectorization.compute, 0x00, 0x0c), :LoopVectorization, :LOOPCONSTANTINSTRUCTION, LoopVectorization.OperationStruct(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x0d), :Main, :partials, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000c0d, LoopVectorization.compute, 0x00, 0x0e), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x04, 0x0f), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x05, 0x10), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x00000000000e0f10, LoopVectorization.compute, 0x00, 0x10), :LoopVectorization, :setindex!, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000011, LoopVectorization.memstore, 0x05, 0x11), :LoopVectorization, :LOOPCONSTANTINSTRUCTION, LoopVectorization.OperationStruct(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x12), :Main, :partials, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000c13, LoopVectorization.compute, 0x00, 0x13), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000002, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x07, 0x14), :numericconstant, Symbol("##reductzero#321"), LoopVectorization.OperationStruct(0x0000000000000002, 0x0000000000000000, 0x0000000000000001, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x15), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000001, 0x0000000000000000, 0x0000000000140f16, LoopVectorization.compute, 0x00, 0x15), :LoopVectorization, :reduced_add, LoopVectorization.OperationStruct(0x0000000000000002, 0x0000000000000001, 0x0000000000000000, 0x0000000000001715, LoopVectorization.compute, 0x00, 0x14), :LoopVectorization, :setindex!, LoopVectorization.OperationStruct(0x0000000000000002, 0x0000000000000000, 0x0000000000000000, 0x0000000000000018, LoopVectorization.memstore, 0x07, 0x16), :LoopVectorization, :LOOPCONSTANTINSTRUCTION, LoopVectorization.OperationStruct(0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x17), :Main, :partials, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000000, 0x0000000000000000, 0x0000000000000c1a, LoopVectorization.compute, 0x00, 0x18), :LoopVectorization, :getindex, LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, LoopVectorization.memload, 0x09, 0x19), :numericconstant, Symbol("##reductzero#327"), LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000000, 0x0000000000000002, 0x0000000000000000, LoopVectorization.constant, 0x00, 0x1a), :LoopVectorization, :vfmadd_fast, LoopVectorization.OperationStruct(0x0000000000000012, 0x0000000000000002, 0x0000000000000000, 0x00000000001b0f1d, LoopVectorization.compute, 0x00, 0x1a), :LoopVectorization, :reduced_add, LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000002, 0x0000000000000000, 0x0000000000001e1c, LoopVectorization.compute, 0x00, 0x19), :LoopVectorization, :setindex!, LoopVectorization.OperationStruct(0x0000000000000001, 0x0000000000000000, 0x0000000000000000, 0x000000000000001f, LoopVectorization.memstore, 0x09, 0x1b)}, Tuple{LoopVectorization.ArrayRefStruct{:A,Symbol("##vptr##_A")}(0x0000000000000001, 0x0000000000000001, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:B,Symbol("##vptr##_B")}(0x0000000000000101, 0x0000000000000102, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:C,Symbol("##vptr##_C")}(0x0000000000000001, 0x0000000000000002, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥ℛℰ𝒮,Symbol("##vptr##_𝛥ℛℰ𝒮")}(0x0000000000000001, 0x0000000000000001, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥B,Symbol("##vptr##_𝛥B")}(0x0000000000000101, 0x0000000000000102, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥B,Symbol("##vptr##_𝛥B")}(0x0000000000000101, 0x0000000000000102, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥C,Symbol("##vptr##_𝛥C")}(0x0000000000000001, 0x0000000000000002, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥C,Symbol("##vptr##_𝛥C")}(0x0000000000000001, 0x0000000000000002, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥A,Symbol("##vptr##_𝛥A")}(0x0000000000000001, 0x0000000000000001, 0x0000000000000000), LoopVectorization.ArrayRefStruct{:𝛥A,Symbol("##vptr##_𝛥A")}(0x0000000000000001, 0x0000000000000001, 0x0000000000000000)}, Tuple{0, Tuple{}, Tuple{2, 5, 8}, Tuple{(19, 2), (26, 3)}, Tuple{}, Tuple{(22, LoopVectorization.IntOrFloat), (29, LoopVectorization.IntOrFloat)}, Tuple{(13, LoopVectorization.HardInt)}}, Tuple{:i, :j}, (var"##i_loop_lower_bound#299":var"##i_loop_upper_bound#300", var"##j_loop_lower_bound#302":var"##j_loop_upper_bound#303"), var"##vptr##_A", var"##vptr##_B", var"##vptr##_C", var"##vptr##_𝛥ℛℰ𝒮", var"##vptr##_𝛥B", var"##vptr##_𝛥B", var"##vptr##_𝛥C", var"##vptr##_𝛥C", var"##vptr##_𝛥A", var"##vptr##_𝛥A", 𝜀A, 𝜀B, 𝜀C, partials, partials, partials)), :A, :B, :C, :𝛥B, :𝛥ℛℰ𝒮, :𝛥C, :𝛥A))
    end
end

Notice that it's passing partials as arguments to the function _avx_!. It stripped the ForwardDiff.
I'll fix this.
Also, I can't run your examples:
julia> f_fwd(A,B,C) = @tullio grad=Dual avx=false s[i] := A[i] * log(B[i,j] / C[j]);
ERROR: LoadError: can't understand LHS, expected A[i,j,k], got grad
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] _tullio(::Expr, ::Expr, ::Expr; multi::Bool, mod::Module) at /home/chriselrod/.julia/packages/Tullio/aaSZU/src/Tullio.jl:83
 [3] @tullio(::LineNumberNode, ::Module, ::Vararg{Any,N} where N) at /home/chriselrod/.julia/packages/Tullio/aaSZU/src/Tullio.jl:53
 [4] eval(::Module, ::Any) at ./boot.jl:331
 [5] eval_user_input(::Any, ::REPL.REPLBackend) at /home/chriselrod/Documents/languages/julia/usr/share/julia/stdlib/v1.5/REPL/src/REPL.jl:132
 [6] run_backend(::REPL.REPLBackend) at /home/chriselrod/.julia/packages/Revise/2K7IK/src/Revise.jl:1070
 [7] top-level scope at none:1
in expression starting at REPL[37]:1

OK, great, had not looked hard at the expanded version. The alternative access like this gives immediate errors:
julia> @macroexpand @avx for i = 📏i
                  for j = 📏j
                      ℛℰ𝒮 = (A[i] + 𝜀A) * log((B[i, j] + 𝜀B) / (C[j] + 𝜀C))
                      𝛥B[i, j] = 𝛥B[i, j] + ℛℰ𝒮.partials[1] * 𝛥ℛℰ𝒮[i]
                   end
               end
ERROR: LoadError: TypeError: in typeassert, expected Symbol, got Expr

I think the error you get might be from master branch, which is last year's attempt, the right branch is coronavirusrewrite... sorry should get around to merging it.

Ah, checking out coronaviruswrite solves that problem.

Is getfield expected to work?

Not yet.
PR's are welcome, otherwise I may get around to it, but probably not until after there's real support for non-hardware types.
On that note, what are A, B, and C?
The same applies to the previous snippet I posted. If they're not arrays of hardware types, loading from them isn't supported yet either.
These are things you could implement, preferably in the way the README demos adding support for Complex{Float64}. But you could also do it in the form of defining a load as a bunch of loads and shufflevectors.
But I don't see where you're defining any such methods at the moment.
Could you also come up with a more minimal example of what you're trying to do?
It's hard for me to see what's going on from the @tullio macro.
I saw that it calls Main.💧82, which calls Main.💥82, and I stopped trying to dissect things from there.

A,B,C are arrays of Float64, and functions apply!/💥 are like mul! in that they work in-place, while create/💧 is like * that first makes the necessary output array. (I got tired of looking at gensyms!) Then ∇💧 is supposed to compute backwards gradients, and similarly calls in-place function ∇💥, which has some loops. Inside these loops there's a scalar computation which can be done using dual numbers, and this is the problematic part.
There are just three dual numbers as input (the same ones at every step), never an array of them. And ordinary numbers partials(res,1) are written back into arrays similar(A) etc. I was hoping that by juggling these Dual{SVec} things this inner "scalar" computation could be made efficient, these objects only have to exist for a few lines, and then get taken apart again.
I agree though that my example is not so minimal, sorry! I will have a go at boiling it down.

OK here's an example small enough just to paste in here:
using LoopVectorization, ForwardDiff, BenchmarkTools

function dualinv!(B,A)
    @assert size(A) == size(B)
    T = eltype(B)
    dx = ForwardDiff.Dual(zero(T), (one(T), zero(T)))
    for i in eachindex(A)
        res = log(A[i] + dx)
        B[i] = ForwardDiff.partials(res,1)
    end
    B
end

dualinv!(rand(5), 1:5) == inv.(1:5)

function dualinv_avx!(B,A)
    @assert size(A) == size(B)
    T = eltype(B)
    dx = ForwardDiff.Dual(zero(T), (one(T), zero(T)))
    @avx for i in eachindex(A)
        res = log(A[i] + dx)
        B[i] = ForwardDiff.partials(res,1)
    end
    B
end

dualinv_avx!(rand(5), collect(1:5.0)) # UndefVarError: partials not defined

using ForwardDiff: partials

dualinv_avx!(rand(5), collect(1:5.0)) # MethodError: no method matching +(::VectorizationBase.SVec{4,Float64}, ::ForwardDiff.Dual{Nothing,Float64,2})

using Tullio # branch coronavirusrewrite, just for Dual Svec definitions

dualinv_avx!(rand(5), collect(1:5.0)) == inv.(1:5)

A = rand(10^6); B = similar(A);

@btime dualinv!($B, $A); # 7.335 ms (0 allocations: 0 bytes)

@btime dualinv_avx!($B, $A); # 12.363 ms (750003 allocations: 49.59 MiB)

If you find basic SVec definitions missing that sound like they should be there, please file an issue at SIMDPirates or SLEEFPirates. SIMDPirates is full of llvmcalls, and SLEEFPirates has more elaborate definitions for special functions like exp and sin. Don't worry too much about which if it isn't immediately obvious to you.
This is for two reasons:

So everyone using LoopVectorization, or SIMDPirates/SLEEFPirates will have the definition available.
So I can make sure the implementation is efficient.

In the case of inv(::SVec{<:Any,<:Integer}), I simply forgot to define inv(v::SVec{<:Any,<:Integer}) =  vinv(v).
Note the difference in the code_native and resulting performance between SIMDPirates.vinv and Tullio.inv:
julia> using Tullio, SIMDPirates, BenchmarkTools

julia> xi = SVec(ntuple(Val(8)) do i Core.VecElement(i) end)
SVec{8,Int64}<1, 2, 3, 4, 5, 6, 7, 8>

julia> @code_native debuginfo=:none SIMDPirates.vinv(xi)
        .text
        movq    %rdi, %rax
        vcvtqq2pd       (%rsi), %zmm0
        movabsq $.rodata.cst8, %rcx
        vbroadcastsd    (%rcx), %zmm1
        vdivpd  %zmm0, %zmm1, %zmm0
        vmovapd %zmm0, (%rdi)
        vzeroupper
        retq
        nopl    (%rax)

julia> @code_native debuginfo=:none inv(xi)
        .text
        pushq   %rbp
        movq    %rsp, %rbp
        pushq   %rbx
        andq    $-64, %rsp
        subq    $192, %rsp
        vxorps  %xmm0, %xmm0, %xmm0
        vmovaps %xmm0, 32(%rsp)
        movq    $0, 48(%rsp)
        movq    %fs:0, %rbx
        movq    $4, 32(%rsp)
        movq    -15712(%rbx), %rax
        movq    %rax, 40(%rsp)
        leaq    32(%rsp), %rax
        movq    %rax, -15712(%rbx)
        vmovups (%rdi), %zmm0
        vmovaps %zmm0, 64(%rsp)
        movabsq $ntuple, %rax
        leaq    64(%rsp), %rdi
        movl    $8, %esi
        vzeroupper
        callq   *%rax
        movq    %rax, 48(%rsp)
        movq    %rax, 56(%rsp)
        movabsq $jl_apply_generic, %rax
        movabsq $139793777923704, %rdi  # imm = 0x7F2446799678
        leaq    56(%rsp), %rsi
        movl    $1, %edx
        callq   *%rax
        movq    40(%rsp), %rcx
        movq    %rcx, -15712(%rbx)
        leaq    -8(%rbp), %rsp
        popq    %rbx
        popq    %rbp
        retq
        nopw    %cs:(%rax,%rax)
        nopl    (%rax,%rax)

julia> @btime SIMDPirates.vinv($(Ref(xi))[])
  3.740 ns (0 allocations: 0 bytes)
SVec{8,Float64}<1.0, 0.5, 0.3333333333333333, 0.25, 0.2, 0.16666666666666666, 0.14285714285714285, 0.125>

julia> @btime inv($(Ref(xi))[])
  27.096 ns (2 allocations: 160 bytes)
SVec{8,Float64}<1.0, 0.5, 0.3333333333333333, 0.25, 0.2, 0.16666666666666666, 0.14285714285714285, 0.125>

OK, it would be great to fix things upstream. But do you just mean things in Base, or would SLEEFPirates be willing to depend on ForwardDiff to have these dual types?
Some of the same issues seem to arise for complex numbers, too. Here's a version of my example above, which similarly tries to use them at an intermediate step:
function cinv!(B,A)
    dx = im/100_000
    for i in eachindex(A)
        res = log(A[i] + dx)
        B[i] = 100_000 * imag(res)
    end
    B
end

cinv!(rand(5), collect(1:5.0)) ≈ inv.(1:5)

function cinv_avx!(B,A)
    dx = im/100_000
    @avx for i in eachindex(A)
        res = log(A[i] + dx)
        B[i] = 100_000 * imag(res)
    end
    B
end

cinv_avx!(rand(5), collect(1:5.0)) ≈ inv.(1:5) # MethodError: no method matching +(::VectorizationBase.SVec{4,Float64}, ::Complex{Float64})

And, here's what happens with inv on my computer (an i7-8700), @code_native differs at length 8 but not length 4:
julia> xi = SVec(ntuple(Val(4)) do i Core.VecElement(i) end)
SVec{4,Int64}<1, 2, 3, 4>

julia> @btime SIMDPirates.vinv($(Ref(xi))[])
  2.200 ns (0 allocations: 0 bytes)
SVec{4,Float64}<1.0, 0.5, 0.3333333333333333, 0.25>

julia> @btime Tullio.inv($(Ref(xi))[])
  2.200 ns (0 allocations: 0 bytes)
SVec{4,Float64}<1.0, 0.5, 0.3333333333333333, 0.25>

julia> xi = SVec(ntuple(Val(8)) do i Core.VecElement(i) end)
SVec{8,Int64}<1, 2, 3, 4, 5, 6, 7, 8>

julia> @btime Tullio.inv($(Ref(xi))[])
  28.119 ns (2 allocations: 160 bytes)
SVec{8,Float64}<1.0, 0.5, 0.3333333333333333, 0.25, 0.2, 0.16666666666666666, 0.14285714285714285, 0.125>

julia> @btime SIMDPirates.vinv($(Ref(xi))[])
Segmentation fault: 11

On the local versions (I plan to push by the end of the day):
julia> using LoopVectorization, ForwardDiff, BenchmarkTools

julia> using ForwardDiff: Dual, Partials

julia> using LoopVectorization: SVec

julia> ForwardDiff.can_dual(::Type{<:SVec}) = true

julia> @inline function Base.:+(x::Dual{Z,T,D}, sv::SVec{N,S}) where {Z,T<:Number,D,N,S}
           y = x.value + sv
           ps = ntuple(d -> x.partials.values[d] + zero(sv), Val(D)) # avoiding partials(x.d) didn't help
           TS = SVec{N,promote_type(T,S)}
           Dual{Z,TS,D}(y, Partials{D,TS}(ps))
       end

julia> @inline function Base.:+(sv::SVec{N,S}, x::Dual{Z,T,D}) where {Z,T<:Number,D,N,S}
           y = x.value + sv
           ps = ntuple(d -> x.partials.values[d] + zero(sv), Val(D))
           TS = SVec{N,promote_type(T,S)}
           Dual{Z,TS,D}(y, Partials{D,TS}(ps))
       end

julia> @inline function Base.:*(x::Dual{Z,SVec{N,T},D}, sv::SVec{N,S}) where {Z,T,D,N,S}
           y = x.value * sv
           ps = ntuple(d -> x.partials.values[d] * sv, Val(D))
           TS = SVec{N,promote_type(T,S)}
           Dual{Z,typeof(y),D}(y, Partials{D,typeof(y)}(ps))
       end

julia> @inline function Base.:*(sv::SVec{N,S}, x::Dual{Z,SVec{N,T},D}) where {Z,T,D,N,S}
           y = sv * x.value
           ps = ntuple(d -> sv * x.partials.values[d], Val(D))
           TS = SVec{N,promote_type(T,S)}
           Dual{Z,TS,D}(y, Partials{D,TS}(ps))
       end

julia> @inline function Base.:*(p::Partials{D,SVec{N,T}}, sv::SVec{N,S}) where {T,D,N,S}
           TS = SVec{N,promote_type(T,S)}
           Partials{D,TS}(ntuple(d -> p.values[d] * sv, Val(D)))
       end

julia> @inline function Base.:*(sv::SVec{N,S}, p::Partials{D,SVec{N,T}}) where {T,D,N,S}
           TS = SVec{N,promote_type(T,S)}
           Partials{D,TS}(ntuple(d -> sv * p.values[d], Val(D)))
       end

julia> function dualinv!(B,A)
           @assert size(A) == size(B)
           T = eltype(B)
           dx = ForwardDiff.Dual(zero(T), (one(T), zero(T)))
           for i in eachindex(A)
               res = log(A[i] + dx)
               B[i] = ForwardDiff.partials(res,1)
           end
           B
       end
dualinv! (generic function with 1 method)

julia> dualinv!(rand(5), 1:5) == inv.(1:5)
true

julia> function dualinv_avx!(B,A)
           @assert size(A) == size(B)
           T = eltype(B)
           dx = ForwardDiff.Dual(zero(T), (one(T), zero(T)))
           @avx for i in eachindex(A)
               res = log(A[i] + dx)
               B[i] = ForwardDiff.partials(res,1)
           end
           B
       end
dualinv_avx! (generic function with 1 method)

julia> dualinv_avx!(rand(5), collect(1:5.0))
5-element Array{Float64,1}:
 1.0
 0.5
 0.3333333333333333
 0.25
 0.2

julia> dualinv_avx!(rand(5), 1:5.0)
5-element Array{Float64,1}:
 1.0
 0.5
 0.3333333333333333
 0.25
 0.2

julia> A = rand(10^6); B = similar(A);

julia> @btime dualinv!($B, $A); # 7.335 ms (0 allocations: 0 bytes)
  5.684 ms (0 allocations: 0 bytes)

julia> @btime dualinv_avx!($B, $A);
  662.525 μs (0 allocations: 0 bytes)

Note that two of your Base.:* methods had a Z in the where clause that didn't show up in the argument types.
I wish that'd throw an error. Instead, it silently causes your code to allocate and run slower.

And, here's what happens with inv on my computer (an i7-8700), @code_native differs at length 8 but not length 4:

Interesting. Maybe there's a limit causing the compiler to give up somewhere between 4 and 8.

julia> @btime SIMDPirates.vinv($(Ref(xi))[])
Segmentation fault: 11

That should be fixed on Julia master.

Ah indeed, that crash was Julia 1.3, but it's fixed on 1.5.
And thanks, deleting that unused where Z fixes this example completely. You did say but I didn't realise this was such a big deal.

It's insidious! It's one of the first things I look for when I run into surprising amounts of allocations.

And thanks, deleting that unused where Z fixes this example completely. It's identical to a loop with B[i] = 1/A[i].

Nice. I was expecting that, because Base.log(::SVec) is inlined, so LLVM should be able to delete it once it sees the result is unused and that it log has no side effects (which it can tell, thanks to the inlining).
Some other methods like Base.exp(::SVec) aren't inlined on all architectures, so this makes me wonder if I should make that consistent. It can sometimes be important, like here.
(exp isn't inlined on Linux with recent GLIBC, because it calls the GLIBC version with ccall.)

OK, it would be great to fix things upstream. But do you just mean things in Base, or would SLEEFPirates be willing to depend on ForwardDiff to have these dual types?

Hmm. ForwardDiff is a heavy dependency.
julia> @time using LoopVectorization
  0.396693 seconds (912.65 k allocations: 63.532 MiB)

julia> @time using ForwardDiff
  2.400366 seconds (10.07 M allocations: 489.370 MiB, 8.63% gc time)

Maybe we can create a ForwardDiffSVec or ForwardDiffLoopVectorization library? Doesn't have to be those names.
It'd take me a while to create a new open source library (I'd have to file for approval, etc). But if you don't mind also depending on PaddedMatrices, I could use PaddedMatricesForwardDiff (which will need updating).
Otherwise, you could create a library, and I can add to VectorizationBase, SIMDPirates, and SLEEFPirates' README's that it is the official/blessed library for ForwardDiff support on SVecs.

Looks like https://github.com/JuliaLang/julia/issues/29393 is the issue about dangling type parameters.
Will fiddle a bit more first, but  PaddedMatricesForwardDiff  doesn't sound like a bad option to store these methods, since it already depends on all the relevant things.

Okay. You're welcome to make PRs there yourself.
It may be a couple months before I work on it myself.


How to use pre-trained SQUAD model?

After training squad, I have a model file in a local folder:
-rw-rw-r--  1 khashab2 cs_danr 4.7M Nov 21 19:20 dev-v1.1.json
-rw-rw-r--  1 khashab2 cs_danr 3.4K Nov 29 22:52 evaluate-v1.1.py
drwxrwsr-x  2 khashab2 cs_danr   10 Nov 30 14:57 out2
-rw-rw-r--  1 khashab2 cs_danr  29M Nov 21 19:20 train-v1.1.json
-rw-rw-r--  1 khashab2 cs_danr 490M Nov 29 23:14 train-v1.1.json_bert-base-uncased_384_128_64
-rw-rw-r--  1 khashab2 cs_danr 490M Nov 30 15:05 train-v1.1.json_bert-large-uncased_384_128_64

I want to use this pre-trained model to make predictions. Is there any example that I can follow this? (if not any pointers?) I looked into the instructions and didn't find anything relevant on this.

Hi there are now examples on how you can save and reload the models in the examples (run_classifier, run_squad and run_swag)


GSF id empty

After flashing this module I found that GSF id is empty. How do I fix this?

Closed as this relates to old MagiskGApps varients.


Adds editor config to ensure EOL before EOF

is this checked on ci?

sadly while many tools honor this, I'm not aware of a linter for it
See https://github.com/editorconfig/editorconfig/issues/103

huh


Chat Page Infinite Load

Thanks to the updates in the latest PR I was able to implement the explore assistant but have not been able to unlock the chat functionality.  Upon clicking the chat button I see a spinning cirlce indicating loading but nothing ever refreshes and I am unable to find anything in the console logs to support this.  Thanks for any help you can provide.

Resolved by loading refinement examples.  Though not explicitly listed, both the example prompts and refinement example tables must be loaded for the chat extension to work.

Hi @ryan-gould-accenture do you have examples of how to load refinement examples table. i loaded the same way as example prompts but i get not valid json error while loading chat screen. TIA


[Feature] Fix for notifications not showing on all dekstop devices?

So this is kinda unrelevant to BetterDiscordApp but rather relevant to the Discord app iself, however the issue seems to be kinda ignored by the Discord developers.
Basically my Discord notifications for Win 10 stopped working back in like 2018-2019 and havent worked since, Ive tried pretty much every "fix" posted in various articles across the internet with no success.
What Ive tried is checking that I have the correct Windows notification settings and correct Discord notification settings as well as the steps described here: https://www.partitionwizard.com/partitionmanager/win-10-notifications-not-working.html as well as that Ive tried deleting .../appdata/local/discord and .../appdata/roaming/discord.
Would it be possible for BetterDiscrd to create an alternative toast notification system for those that are in my situation? It seems like a relatively common issue looking around the web there are many forums of people having the same issue as I do

This is technically possible--to have in-app notifications--but is better suited to a plugin. Try the plugin-ideas channel on the server.


[Do not review] Poc code for local cache

Poc code for reading from local cache.

Close it because it's not needed.


Restructure headings

All the headings were top level headings while they (probably) should be second level.

This seems like a small (but important) contribution, so no Contribution License Agreement is required at this point. We will now review your pull request.
Thanks,
.NET Foundation Pull Request Bot

Yep, looks better. Thanks.


onFocus of Editor doesn't gets fired everytime in IE11

The onFocus event gets called intermittently on ie11

Can you provide a jsfiddle with a minimal repro?

Looks like this has gotten stale, and we need more info in order to reproduce the bug. Closing for now - please do open a new issue with more details if you can @abhijeetahuja since we want to document and fix any browser bugs. :)


Add class or wrapping div to iframe?

Would it be possible to add a config setting that would allow for class names on the iFrame, or, better yet, a wrapping div with a custom className?

Hi @mikestecker,
I think I'd rather prefer an option like this added to https://github.com/remark-embedder/core Which would allow you to do something like this:
function handleHTML(html, {url, config}) {
  if (!isUrlIWantToChange(url, config)) return html

  return `<div class="whatever">${html}</div>`
}

const result = await remark()
  .use(remarkEmbedder, {
    transformers: [oembedTransformer],
    handleHTML,
  })
  .use(html)
  .process(exampleMarkdown)

I'll transfer this issue. Would you be interested in working on that?


Update azure-automation.md

Added line 108 Update-MaesterTests to get the latest tests

@BurgerhoutJ have you run into an issue with stale tests? The Install-MaesterTest calls the same function as Update-Maester the only difference is the check for existing folder.
So adding this extra command is not going to make any new changes.

Strange. When I added the update-maestertests, after the run I had 240+ tests instead of the 135 the first few times.
I will check it again with and without the added command.

Were you able to repro the issue @BurgerhoutJ ?

Sorry. Didn't have the time this week to repro.
You can close this pull request.


bug: Rogcat fails to start with stdin parameter

{code}
./target/debug/rogcat -
thread 'thread 'tokio-runtime-worker-0tokio-runtime-worker-1' panicked at '' panicked at 'attempted to leave type internal::Local uninitialized, which is invalidattempted to leave type internal::Local uninitialized, which is invalid', ', /rustc/c8dfcfe046a7680554bf4eb612bad840e7631c4b/library/core/src/mem/mod.rs/rustc/c8dfcfe046a7680554bf4eb612bad840e7631c4b/library/core/src/mem/mod.rs::663663::99
{code}
This is a problem with Crossbeam 0.7.1. Update to 0.7.2 will help.
It's discussed here: https://github.com/darakian/ddh/issues/27

Thanks for the report. Where in the dependency chain is crossbeam-epoch used? Maybe updating the crate that depends on it make more sense than just add a "unused" dependency #38

Should be fixed.


Make an option to force enable the polyfill

For people who comes across this:
I found Edge support for position: sticky was so unreliable, forcing this polyfill on it was a better option. For anyone who's curious, I hacked the following:
// The polyfill cant’t function properly without `getComputedStyle`.
if (!window.getComputedStyle) seppuku = true;
// Dont’t get in a way if the browser supports `position: sticky` natively.
else {
    const testNode = document.createElement('div');

    if (
        ['', '-webkit-', '-moz-', '-ms-'].some(prefix => {
            try {
                testNode.style.position = prefix + 'sticky';
            }
            catch(e) {}

            return testNode.style.position != '';
        })
    ) seppuku = true;
}
+ // hack to force ignore MS Edge sticky support
+ if (/Edge/.test(navigator.userAgent)) {
+    seppuku = false;
+ }

wilddeer:
I'd have liked to have provided a something a bit more solid improvement, but not sure how it would work with the existing initial test, and if a rewrite would be OK. I'd be happy to have a go if you could offer some idea of what you were planning.

Yep, this feature would be so nice to have!
Editing a postion:sticky-ied input in chrome 61 forces a scroll to the top. I'd love to use this polyfill instead of native support.

@wilddeer any movement on this? perhaps we could just provide an initialization option to force the polyfill? i.e.
const stickyFill = new Stickyfill({ forceSticky: true });

We now have Stickyfill.forceSticky(). Rejoice!


Support using cookies from Arc browser

DO NOT REMOVE OR SKIP THE ISSUE TEMPLATE

[X] I understand that I will be blocked if I intentionally remove or skip any mandatory* field

Checklist

[X] I'm requesting a feature unrelated to a specific site
[X] I've looked through the README
[X] I've verified that I'm running yt-dlp version 2023.07.06 (update instructions) or later (specify commit)
[X] I've searched known issues and the bugtracker for similar issues including closed ones. DO NOT post duplicates
[X] I've read the guidelines for opening an issue

Provide a description that is worded well enough to be understood
Arc is a (relatively) new browser based on Chromium. Please add support for using cookies via --cookies-from-browser for Arc web browser.
Provide verbose output that clearly demonstrates the problem

[X] Run your yt-dlp command with -vU flag added (yt-dlp -vU <your command line>)
[ ] If using API, add 'verbose': True to YoutubeDL params instead
[X] Copy the WHOLE output (starting with [debug] Command-line config) and insert it below

Complete Verbose Output
[debug] Command-line config: ['--cookies-from-browser', 'arc', '-vU', 'https://weverse.io/wooah/live/3-126751905']

Usage: yt-dlp [OPTIONS] URL [URL...]

yt-dlp: error: unsupported browser specified for cookies: "arc". Supported browsers are: brave, chrome, chromium, edge, firefox, opera, safari, vivaldi

See pinned issue https://github.com/yt-dlp/yt-dlp/issues/2903

Sorry to reopen something you've already closed, but I was working through this issue today and the solution proposed in #2903 doesn't work for Arc. I found the cookies file in the normal place, but it can't seem to find the keychain to decrypt the file.
[debug] User config "/Users/alexandra/.config/yt-dlp/config": ['-o', '~/Downloads/%(original_url)s-%(upload_date)s-%(title)s.%(ext)s', '--cookies-from-browser', 'chromium:~/Library/Application Support/Arc/User Data/']
[debug] Encodings: locale UTF-8, fs utf-8, pref UTF-8, out utf-8, error utf-8, screen utf-8
[debug] yt-dlp version<EMAIL_ADDRESS>[b532a3481] (pip)
[debug] Python 3.9.16 (CPython arm64 64bit) - macOS-13.4.1-arm64-arm-64bit (OpenSSL 1.1.1t  7 Feb 2023)
[debug] exe versions: ffmpeg 5.1.2 (setts), ffprobe 5.1.2
[debug] Optional libraries: Cryptodome-3.17, brotli-1.0.9, certifi-2022.12.07, mutagen-1.46.0, sqlite3-2.6.0, websockets-10.4
[Cookies] Extracting cookies from chromium
[debug] Extracting cookies from: "/Users/alexandra/Library/Application Support/Arc/User Data/Profile 1/Cookies"
[debug] using find-generic-password to obtain password from OSX keychain
WARNING: find-generic-password failed
[Cookies] Loading cookie      0/    13WARNING: cannot decrypt v10 cookies: no key found
[Cookies] Extracted 0 cookies from chromium (13 could not be decrypted)
[debug] cookie version breakdown: {'v10': 13, 'other': 0, 'unencrypted': 0}
[debug] Proxy map: {}
[debug] Loaded 1855 extractors
[WatchESPN] Extracting URL: https://www.espn.com/watch/player/_/id/4f037325-6082-4c61-8581-bcf03dcc936b
[WatchESPN] 4f037325-6082-4c61-8581-bcf03dcc936b: Downloading JSON metadata
ERROR: [WatchESPN] 4f037325-6082-4c61-8581-bcf03dcc936b: This video is only available for registered users. Use --cookies-from-browser or --cookies for the authentication. See  https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp  for how to manually pass cookies
  File "/Users/alexandra/.pyenv/versions/p39/lib/python3.9/site-packages/yt_dlp/extractor/common.py", line 710, in extract
    ie_result = self._real_extract(url)
  File "/Users/alexandra/.pyenv/versions/p39/lib/python3.9/site-packages/yt_dlp/extractor/espn.py", line 353, in _real_extract
    self.raise_login_required(method='cookies')
  File "/Users/alexandra/.pyenv/versions/p39/lib/python3.9/site-packages/yt_dlp/extractor/common.py", line 1170, in raise_login_required
    raise ExtractorError(msg, expected=True)```

Based on some googling, it seems like that while Arc is a Chromium-based browser, it doesn't allow for use of Google profiles and instead uses its own user-defined local profiles. That also means that it doesn't use the Google Password Manager, which seems to be the usual Chromium function that allows `cookies.py` to decrypt the cookies file.

I wasn't able to come up with a solution this afternoon, and I can understand if you all don't want to support a hyper-niche browser, but I thought I'd at least comment here so that if anyone else runs into this issue, they understand what's going on. Happy to help in whatever way I can if you do want to support development for cookies in this browser, though!

I took a look, and this is a MacOS only browser at the moment and it is closed source so this is either going to be tricky or very tricky to support.
In the past I have used OSX-KVM to test out MacOS browsers but for some reason opening Arc in this VM completely tanks performance* to an unusable level (approximately 15 seconds per frame... not frames per second), so unless anyone has a solution to the VM being slow I won't be able to help.
*I have KVM enabled. My CPU has VT-x. I have run osx-optimizer. I tried both Monterey and Ventura. I tried allocating more RAM and CPU cores. I have an Nvidia GPU so I can't use GPU passthrough which I suspect would help at least a bit. MacOS itself and Safari are fairly responsive, Chrome is less responsive but still usable for testing

Works for me on macOS by using the following:
--cookies-from-browser "chromium:$HOME/Library/Application Support/Arc/User Data/Default"


output for test images in /src/tests/test_images/

@clennan  Can you please provide scores for the test images in /src/tests/test_images/ ?

Hi, here are the scores
technical model (models/MobileNet/weights_mobilenet_technical_0.11.hdf5)
[
  {
    "image_id": "42039",
    "mean_score_prediction": 4.647608995437622
  },
  {
    "image_id": "42042",
    "mean_score_prediction": 3.9691513180732727
  },
  {
    "image_id": "42041",
    "mean_score_prediction": 4.996936075389385
  },
  {
    "image_id": "42040",
    "mean_score_prediction": 4.303698688745499
  },
  {
    "image_id": "42044",
    "mean_score_prediction": 3.986619558185339
  }
]

aesthetic model (models/MobileNet/weights_mobilenet_aesthetic_0.07.hdf5)
[
  {
    "mean_score_prediction": 5.228229299085797,
    "image_id": "42039"
  },
  {
    "mean_score_prediction": 5.127163522876799,
    "image_id": "42042"
  },
  {
    "mean_score_prediction": 5.28654936273233,
    "image_id": "42041"
  },
  {
    "mean_score_prediction": 4.6879015052109025,
    "image_id": "42040"
  },
  {
    "mean_score_prediction": 5.79500457971551,
    "image_id": "42044"
  }
]


PR Template Not working

The PR template is not showing up when we create a PR. I would love to work on this and correct it. Kindly assign me this issue as a part of  Girl Script Summer Of Code.

Ok you can work on it.

@muthuannamalai12 are you working on this or should I close this issue?

@muthuannamalai12 are you working on this or should I close this issue?

I have created a Pr no: #29 for this issue and it has been merged too

Oh ok.


Reenable test in rhel 8.4

Add context to test and reenable it

This is failing still failing in 8.4. But my understanding from the bugzilla is that is shouldn't fail...


Update package to remove CLI as dep for client

SwiftGraphQLCLI is not needed for applications using SwiftGraphQLClient and it brings along many dependencies like Spinner, Files, Yams as well as swift-format and, indirectly, SwiftSyntax which does not follow SemVer and easily causes conflicts (see discussion here).
Please consider moving SwiftGraphQLCLI to its own package.

Yep agreed! I raised this the other day with maticzav as well and we agree.
I'll likely address this tomorrow or early next week 👍

Hey all, I unfortunately got sick and didn't manage to get to this. I now have some other priorities so if anyone else sees this in the next week or two and wants to pick it up, feel free to do so thanks! @pokryfka / @maticzav

@shaps80 do you know of any Swift project that has two packages in the same repository and we could use as reference to do this?

Yeah I think I might have one myself. I've looked into this separately and I think I worked out the issue and maybe even resolved it. I'll look into this again later as I'm not working today. My son is home so I won't be able to get much done till tomorrow.

Before my attempt in this PR  (which moves CLI to a separate package) I played around with a sub-package for the CLI as well.
I had some success but the tricky part I ran into was exposing the CLI to the importer of swift-graphql via a plugin.
I was able to get it working but I did some weird stuff where I made a plugin in swift-graphql that looks up the path of the sub-package CLI executable and calls it using Process.
This smells bad to me (which is why I pursued separating the package entirely).
The biggest issue with it was that it required me to disable the sandbox in the plugin since there wasn't any way to allow the execution of another executable from within the build directory (for obvious reasons).
Anyway, just food for thought. Perhaps there's another way to sub-package that doesn't suffer from the same problem.
I suppose that in the current workflow the CLI leans towards beig built and installed on the dev machine rather than run as a package plugin/executable. I definitely prefer the package plugin/executable structure since it's one step simpler but that's just an opinion.

Happy to take this on if I can get some direction on:

Do we want a  separate package or sub-package?
Any requirements or constraints there are about how the user interacts with the CLI?

@CrownedPhoenix this is ultimately the goal however considering the large scale changes that are in progress right now for v6, it's premature to attempt this just yet. However once we get more of the core library in a branch where others can test, this is likely a step we'd be keen on. Again, we're not there yet and we do not want to introduce large scale effort into v5 right now.


Package net-tools in the snap

Fixes: https://github.com/ubuntu/microk8s/issues/148

Thanks @kwmonroe


update error from 1.1.1 to 1.3

While I was trying to update from 1.1.1 to newer version, 1.3, I got error below on Ubuntu 14.04:
	Updating capybara-webkit
	Building native extensions.  This could take a while...
	ERROR:  Error installing capybara-webkit:
		ERROR: Failed to build gem native extension.

	    /home/ekrem/.rbenv/versions/2.1.2/bin/ruby -r ./siteconf20140820-15378-1eun8c9.rb extconf.rb
	cd src/ && ( test -e Makefile.webkit_server || /usr/lib/x86_64-linux-gnu/qt5/bin/qmake /home/ekrem/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/capybara-webkit-1.3.0/src/webkit_server.pro -spec linux-g++ -o Makefile.webkit_server ) && make -f Makefile.webkit_server
	Project ERROR: Unknown module(s) in QT: webkitwidgets
	make: *** [sub-src-webkit_server-pro-make_first-ordered] Error 3
	Command 'make' failed

	make "DESTDIR=" clean
	cd src/ && ( test -e Makefile.webkit_server || /usr/lib/x86_64-linux-gnu/qt5/bin/qmake /home/ekrem/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/capybara-webkit-1.3.0/src/webkit_server.pro -spec linux-g++ -o Makefile.webkit_server ) && make -f Makefile.webkit_server clean
	Project ERROR: Unknown module(s) in QT: webkitwidgets
	make: *** [sub-src-webkit_server-pro-clean-ordered] Error 3

	make "DESTDIR="
	cd src/ && ( test -e Makefile.webkit_server || /usr/lib/x86_64-linux-gnu/qt5/bin/qmake /home/ekrem/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/capybara-webkit-1.3.0/src/webkit_server.pro -spec linux-g++ -o Makefile.webkit_server ) && make -f Makefile.webkit_server
	Project ERROR: Unknown module(s) in QT: webkitwidgets
	make: *** [sub-src-webkit_server-pro-make_first-ordered] Error 3

	make failed, exit code 2

	Gem files will remain installed in /home/ekrem/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems/capybara-webkit-1.3.0 for inspection.
	Results logged to /home/ekrem/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/extensions/x86_64-linux/2.1.0-static/capybara-webkit-1.3.0/gem_make.out

I was able to install and build it when it was 1.1.1. Since then, what is changed, what is missing?

What would be the equivalents of the libqt5webkit5-dev and libgstreamer0.10-dev packages for Yosemite 10.10? I'm having these same errors and I can't figure out how to solve them.

@CoralWeigel any suggestions?

@estepan Have you found this yet? https://github.com/thoughtbot/capybara-webkit/wiki/Installing-Qt-and-compiling-capybara-webkit
I suggest fiddling around with that and seeing if you mess with it enough if you can get it to work (it's qt5, not qt55, by the way)


Y24-137 - [BUG] The volume that is sequenced for a pool is editable, allowing that value to be anything.

Describe the bug
The volume field for a pool sequencing is editable and it is persisted as well. This allows the volume of a sequenced pool to be anything.
Expected behaviour
Disable the volume field while sequencing pools (Create run page -> Add Pool to well )

Additional context
This might need to be revisited later to properly consider how the volume field should behave for pool sequencing.

New stories being created will fix this issue

Following stories were created

https://github.com/sanger/traction-service/issues/1348
https://github.com/sanger/traction-ui/issues/1784
https://github.com/sanger/traction-ui/issues/1785


Add extra log for failing to load variables

There is a flaky in tensorflow/serving. There is a chance for loading a new model version to fail and then following version would all fail with the The specified SavedModel has no variables; no checkpoints were restored
related to this https://github.com/tensorflow/serving/issues/1027
Which would cause the serving model have non-initialized weights error.
Adding this extra log would help us understand more on why it's failing

Can you add a line break before  << variables_index_path;? It's above the 80 character limit, and causing the linter to complain.
@yifeif how is clang-format looking?

there is an error with ImportError: cannot import name 'gen_collective_ops'
i don't see how they are connected


Fixed gradient brush target rectangles.

What does the pull request do?
As described in #5947, when drawn via the DrawingContext gradient brushes were not taking the origin of the target rect into account, only the size - meaning that primitives drawn away from the origin were incorrectly filled.
This PR changes the methods which currently accept a Size accept a Rect in order to create the brush rect.
Fixed issues
Fixes #5947.

Hi, this merge request breaks a behaviour I relied on. I'm drawing a pie chart, built with multiple shapes laying in a canvas, which shared the same gradient background. On 10.6 the gradient went from top to bottom, now it is repeating it self in the middle. From the changes I see, I can't find an easy method to restore the old behaviour?
 <ItemsControl Width="400" Height="400" Items="{Binding PieWedges}">             <ItemsControl.ItemsPanel>                 <ItemsPanelTemplate>                     <Canvas></Canvas>                 </ItemsPanelTemplate>             </ItemsControl.ItemsPanel>             <ItemsControl.ItemTemplate>                 <DataTemplate>                     <pie:PiePiece                         Rotation="{Binding Rotation}"                         WedgeAngle="{Binding Angle}"                         Radius="{Binding OuterRadius}"                         InnerRadius="{Binding InnerRadius}"                         CenterX="200"                         CenterY="200"                         Fill="{Binding Fill}">                     </pie:PiePiece>                 </DataTemplate>             </ItemsControl.ItemTemplate>         </ItemsControl>

Oh dear :( I really thought this wouldn't affect anyone because the behavior introduced here is consistent with WPF... Looks like we either need to revert this change or add a setting to control it.

Yeah I think I agree with @kekekeks - we should revert this change. I'll open a PR to do that.


Bug 2106258: All pages are crashed [4.11]

📝 Description
Bug 2106258: All pages are crashed [4.11]

/lgtm


Prevent cycles in schemas for embedded objects

Currently embedded objects can be defined with cycles - e.g. an embedded object linking to itself. This is not supported in JSON schema and thus sync. We should disallow such schemas either completely (allowing us to throw a compile-time error) or for synchronized Realms (resulting in a runtime error).

➤ Brian Munkholm commented:
Can this be done just in ObjStore or is support in each SDK needed as well?

➤ Christan Melchior commented:
Given that we historically try to avoid having to much difference between Synced and Normal Realms, I would probably prefer we disallow schema cycles between embedded classes completely, which enable us to catch these at compile time. Embedded Objects already have enough caveats, so adding more to the mix would make it even harder for people to understand exactly how they work.

➤ Christan Melchior commented:
It should also be in ObjectStore, but that can only produce runtime exceptions. Any compile-time checks would need to be done by each SDK.

➤ Ian Ward commented:
In speaking with [~nikola.irinchev] and [~redbeard0531] support for this appears to be explicitly defined as a Goal in the Scope here:
{quote}An embedded object can also recursively embed objects of the same type.
For example, a “Dog” embedded object class can contain a field named “puppies” which is a list of “Dog”.{quote}
(See bullet directly above this heading: https://docs.google.com/document/d/1VHNKaieX7DL6ZYJd7-swTqQWzAbrxbUWIM6oTEn7G2k/edit#heading=h.li1hf5o5yox6 ( https://docs.google.com/document/d/1VHNKaieX7DL6ZYJd7-swTqQWzAbrxbUWIM6oTEn7G2k/edit#heading=h.li1hf5o5yox6 ))
We need to get an estimate from the Cloud team on what it would take to implement this in the server.

➤ Brian Munkholm commented:
[~nikola.irinchev] Can you take this with the Cloud team? /cc [~rahul.singhania]

➤ Adam Chelminski commented:
I just looked into this and very roughly, I think the work involved would be:
[Realm Cloud Core]

support recursion in our fork of gojsonschema (see: https://json-schema.org/understanding-json-schema/structuring.html#recursion)
add support for recursive embedded schemas in baas's schema generation and validation framework

[Realm Cloud Sync]

properly map recursive embedded schemas from JSON schema to Realm, and vice versa
update the sync config validation step of verifying that all embedded schemas with the same title have the same schema to consider that the $ref in the recursive embedded schema may have a different value depending on the top-level schema it's embedded in
properly handle recursive embedded schemas in unbound embedded schemas

I would estimate this as several eng weeks to do properly, so it might make sense to add this as a roadmap item to discuss in future quarterly planning meetings.
I could be missing something here that could make this project much more complex or much simpler, and think [~josh.madewell] would be the best person to chip in here since he's most familiar with how baas uses gojsonschema.

➤ Nikola Irinchev commented:
Side note: It appears that using the $definitions syntax, we can greatly simplify the schema handling of embedded objects. The downside is that it may result in the schema applier significantly altering the shape of the user-defined json schema. E.g. if a user inlined the embedded object definitions, but then an SDK added a property, the applier may extract the embedded object definition into the $definitions section and replace all the references with a $ref field.
On-topic: it appears that this is a moderately major undertaking, estimated to at least a couple of weeks with a non-trivial amount of unknowns that may impact GraphQL. Combined with the fact that we don't have the resources to handle it on the cloud side in the near term, we need a decision from the product team on what to do in the near term:
a) prevent cycles client side - this should be relatively easy to do as we have the schema and can easily traverse it and detect a cycle
b) detect a cycle on the server and throw a more comprehensive error - this is more complicated than a) because we don't always have the complete schema readily available ([~adam.chelminski] to confirm)
c) do nothing and throw an obscure error from the server

➤ Brian Munkholm commented:
[~ian.ward] [~drew.dipalma] I think we need your input on this one.

➤ Ian Ward commented:
[~brian.munkholm] Can I get a complexity estimate from the one of the SDKs on what it would take to implement this? My assumption is that it would relatively trivial for the SDK to detect this at compile time and throw an error. If that is not the case then please correct it. We could have this as a quick follow-on task after GA but I kind of feel like that would be a breaking change - however this seems to be a pretty niche corner case that I don't think many people will get into so maybe we can sneak it under the radar?
[~mpobrien] [~adam.chelminski] What happens today on the server side if a client sdk sends changes with recursively embedded objects? Do we throw an error and block the connection or ?

➤ Brian Munkholm commented:
Perhaps [~christian.melchior] or [~nikola.irinchev] can give an estimate for the work involved?

For a runtime algorithm detecting cycles of embedded objects, it'll probably be a few days and can be done in OS and shared between all SDKs. A compile-time approach will depend on whatever tool the SDK uses to process the users' assemblies. The algorithm itself will probably be fairly similar, but it will require that each SDK implements it on its own (with js again relying on runtime cycle detection.

➤ Adam Chelminski commented:

What happens today on the server side if a client sdk sends changes with recursively embedded objects? Do we throw an error and block the connection or ?

I haven't tested it, but if I had to guess, we would reject the changeset that uploads the schema change instructions containing the recursively embedded schema.

➤ Ian Ward commented:

For a runtime algorithm detecting cycles of embedded objects, it'll probably be a few days and can be done in OS and shared between all SDKs.

Thanks Nikola. [~brian.munkholm] can we get this assigned as a runtime exception - which SDK can take this up?

➤ Brian Munkholm commented:
I think this should be doable by the Core team. But also doesn't seem critical for GA, so we will review and assign next week.

➤ Ian Ward commented:
[~nikola.irinchev] [~yavor.georgiev] Would this be a breaking change from the SDKs? If we all of a sudden removed embedded object cycles? I mean I don't feel like its a common pattern but I'd like to understand the behavior here - if its breaking maybe best to get this in before we GA since we have flexibility on timing right now

➤ Nikola Irinchev commented:
Depends on whether we disable it for synced Realms only or for all Realms. It never worked for synced Realms, so it won't be taking away functionality there. If we disallow it for local Realms, then it'll be breaking, yes.

➤ Brian Munkholm commented:
So if it should be done before GA depends on if we also want to prevent cycles for local realms. That seems like a product decision.
Perhaps others have input to this? [~ian.ward] [~christian.melchior] [~thomas.goyne] [~kenneth.geisshirt] [~jason.flax] ?
Shoudl we just disallow cycles for synced or also for local realms?

➤ Nikola Irinchev commented:
Ultimately, we want to support schema cycles, so perhaps it makes sense to allow them for local Realms. On the other hand, this introduces yet another caveat for people looking to switch from a local to a synchronized Realm. Since supporting cycles is technically possible and ultimately, desirable, perhaps product/cloud should weigh in on when the server will be able to add support. If it's a matter of weeks/months, perhaps the best course of action is to disallow it for synced Realms only. If it'll take longer, disallow for all.

➤ Ian Ward commented:
We do not want to diverge non-sync realms and synced realms unless there is a truly compelling use case and we are getting a signal from our community. This was supposed to already be allowed in the server, it was simply an oversight that was missed in the scope goals cc. [~drew.dipalma] [~rahul.singhania]
Since embedded objects is brand new we can disallow cycles and then remove the restriction in a minor version update in a later version when the cloud team is ready

➤ Simon Ulsnes commented:
Since the limitation is server-side, I believe the cycle detection should live on the server.
The most compelling reason (to me) is that involving the client in this requires a protocol change.
All clients are currently able to support nested embedded objects just fine, but if we put the cycle detection on the client without breaking the protocol, we end up with a situation where a client can receive a schema from the server containing cycles once the server is updated with this functionality, but the client is still at a version where it believes that such a schema cannot occur.
Add to this the fact that anybody can send Sync changesets if they are determined enough - not just Sync clients. So we cannot rely on the client for this type of validation. If we do implement some cycle detection on the client, the server would still have to do it.
In other words, I believe the server should perform this validation and return an error to the user if they do define a schema containing cycles between embedded objects. This way such a schema can never make it into the main history, and we don't have to bump any protocol versions once the server gains support for this.

I don't see why this is a protocol breaking change on the Client? We just throw a runtime exception when opening the Realm? (and ideally even at compile time).
IMO waiting until you Sync with the server is a bit too late and will cause a lot of frustration. If there are concerns about how the server reacts to rogue changesets, it sounds like an argument for implementing it on both the server and clients?

➤ Nikola Irinchev commented:
The server already detects these cycles and errors out before any changesets get integrated. The issue is that the message is very obscure and unhelpful - and making it helpful isn't trivial as that will require building a compete graph of the schema.
Throwing on opening a Realm should be fine and future proof as there's no way for an app released today to be built with the expectation that eventually it'll consume embedded schema cycles. Note that the expectation here is that the client-side validation will be applied only to developer-provided schemas and not to the actual schema of the Realm file (allowing for sync to eventually integrate instructions that will result in cyclic schemas).
Finally, implementing it client side is fairly easy compared to doing it server side, which is compounded by the fact there are 20+ SDK engineers vs 4 (one of whom started a week ago) on the server team.

➤ Adam Chelminski commented:
I actually just wrote a test in the server code, and it looks like attempting to upload a schema with a recursive schema will be rejected with an obscure error message as Nikola says, but it also corrupts the app's JSON schema configuration in such a way that makes sync unusable, since it will update the JSON schema in such a way that it replicates the embedded schema one level deep, but it won't recurse deeper than. I think this is an issue that might warrant actually doing this check on the server-side as well, but I agree with others that we should also implement the validation client-side, since this will not be trivial to implement.

➤ Michael O'Brien commented:

I actually just wrote a test in the server code, and it looks like attempting to upload a schema with a recursive schema will be rejected with an obscure error message as Nikola says, but it also corrupts the app's JSON schema configuration in such a way that makes sync unusable

It sounds like a bug that the server would reject recursive schema instructions while still resulting in an update to the JSON schema definition in the app - seems like if the server can reject the offending changesets it should also have been able to protect the schema from getting updated to an invalid state. [~adam.chelminski] can you provide more background on how this got triggered?

➤ Simon Ulsnes commented:
IMO it is a bit problematic if the protocol version cannot be reliably used to determine server/client compatibility. It defeats the purpose of versioning the protocol. Although the server is usually newer than the client, this will not always be the case.

The issue is that the message is very obscure and unhelpful - and making it helpful isn't trivial as that will require building a compete graph of the schema.

Ok, but that is what we would have to do client-side as well. Maybe it is much easier on the client?
Anyway, the point stands that this is a usability concern, and cannot be a validation concern. Note that we should do this in the Object Store rather than Sync, but only for Sync'ed realms - the reason being that Sync does not know about table/column renaming taking place in Object Store, and that the main goal is usability. But this complicates matters a bit, because it ties in with schema migration in Object Store, so it happens at "weird" times (though usually startup). The best thing would be compile-time, but that isn't possible for all SDKs.
In short, I'm fine with implementing cycle detection on the client side for outgoing changesets as a stopgap measure, but we are leaking internal implementation details in a huge way here.
Furthermore, I believe we should start thinking about how we want to express the schema in the protocol in the not-too-far future. (And also, that Carthage must be destroyed.)

➤ Adam Chelminski commented:

It sounds like a bug that the server would reject recursive schema instructions while still resulting in an update to the JSON schema definition in the app - seems like if the server can reject the offending changesets it should also have been able to protect the schema from getting updated to an invalid state. Adam Chelminski can you provide more background on how this got triggered?

Yeah so the reason we reject the schema change is because we apply the schema change successfully, but then we error when refreshing the schema provider because suddenly the schema is now incompatible with sync. I agree that this is a bug.
The two approaches we could take here are to apply schema changes provisionally and check that they are still compatible with sync, or actively search for schema cycles before applying schema changes. I think actively looking for cycles is the better approach since it will allow us to produce better error messages. I just filed https://jira.mongodb.org/browse/REALMC-6985 to address the bug, and if we go with the approach of cycle detection we can improve the error message as well.

➤ Brian Munkholm commented:
Decision: Detect and reject for both local and synced realms.

➤ Adam Chelminski commented:
I've just put up the PR to detect these cycles in the server before they are applied to the JSON schema https://github.com/10gen/baas/pull/3368
A sample error message if a client tried to add a new column to a deep embedded object table that referenced back to an embedded schema that contained to it would be:
failed to validate upload changesets: embedded schema table "deepEmbeddedTable" has cycle at path "linkToPrevLevel.deepEmbeddedObjField"


Speed up AbstractCollectionProperty#add

AbstractCollectionProperty#add was always computing String.format for a message that doesn't always get printed
Adding an if check so the work only happens when needed.
Fixes #20883
Context
For large projects this logging statement can cost >100ms of work in configuration time.
Contributor Checklist

[x] Review Contribution Guidelines
[x] Make sure that all commits are signed off to indicate that you agree to the terms of Developer Certificate of Origin.
[x] Make sure all contributed code can be distributed under the terms of the Apache License 2.0, e.g. the code was written by yourself or the original code is licensed under a license compatible to Apache License 2.0.
[x] Check "Allow edit from maintainers" option in pull request so that additional changes can be pushed by Gradle team
[x] Provide integration tests (under <subproject>/src/integTest) to verify changes from a user perspective
[x] Provide unit tests (under <subproject>/src/test) to verify logic
[x] Update User Guide, DSL Reference, and Javadoc for public-facing changes
[x] Ensure that tests pass sanity check: ./gradlew sanityCheck
[x] Ensure that tests pass locally: ./gradlew <changed-subproject>:quickTest

Gradle Core Team Checklist

[ ] Verify design and implementation
[ ] Verify test coverage and CI build status
[ ] Verify documentation
[ ] Recognize contributor in release notes

@bot-gradle test and merge

OK, I've already triggered a build for you.

Thank you Aurimas!
This will be in 7.5, see https://github.com/gradle/gradle/pull/20955


⚠ Bofrost.de has degraded performance

In c38f978, Bofrost.de (https://www.bofrost.de) experienced degraded performance:

HTTP code: 200
Response time: 1257 ms

Resolved: Bofrost.de performance has improved in 7052795.


Wait DRDY bit got to "1"

Instead of waiting for the DRDY transition to "1," the code is doing the opposite:
    /* wait DRDY bit go to '1' */
      do {
        ret += sths34pf80_tmos_drdy_status_get(ctx, &status);

      } while (status.drdy != 0U);

loop condition should be:
while (status.drdy == 0U);

Instead of waiting for the DRDY transition to "1," the code is doing the opposite:
    /* wait DRDY bit go to '1' */
      do {
        ret += sths34pf80_tmos_drdy_status_get(ctx, &status);

      } while (status.drdy != 0U);

loop condition should be: while (status.drdy == 0U);

Yes, correct, sorry for the typo. I'll prepare a new driver version.

Please let me know if this issue is fixed. If other problems still persists, I think we may open a different bug

fixed by 7c88a3e


[release-v0.13] fix: change fedora template from tiny to medium

What this PR does / why we need it:
[release-v0.13] fix: change fedora template from tiny to medium
fedora tiny was removed from common-templates. The e2e tests need to be adjusted to use fedora medium template.
Release note:
NONE

/retest


The issue inside a cluster when trying k8s-cookbook recipe 5.2 'Verifying a DNS entry of a service'

This issue is related to k8s-cookbook recipe 5.2 'Verifying a DNS entry of a service'
I used a VMWare workstation player to install 2 VMs with Ubuntu 16.04 LTS, and installed Docker 18.06CE / Kubeadm 1.7.8 / Weave Network as my test environment (I knew there is Kuberentes 1.12 ready but I stll got this very same problem a few weeks ago, hence I decided to fall-back to version 1.7 you mentioned in this book).
Thing went well for all components installation until I completed 'kubeadm init' & 'kubeadm join' & created a few pods/svc. When I followed section 5.2 to launch busybox interactively, using 'nslookup nginx' simply returned an error: ";; connection timed out; no servers could be reached". I am pretty sure that my components are up 'n running:
my kube-dns pod was running (EndPoint IP <IP_ADDRESS>) & DNS service is up (ClusterIP <IP_ADDRESS>)
my nginx pod was running (EndPoint IP <IP_ADDRESS>) & nginx service is exposed (ClusterIP <IP_ADDRESS>)
However, when I checked logs of my kubedns pod and its container sidecar, lots of error entries there:
ERROR: logging before flag.Parse: W1009 07:13:42.157859      24 server.go:64] Error getting metrics from dnsmasq: read udp <IP_ADDRESS>:37999-><IP_ADDRESS>:53: i/o timeout
Looks like while my sidecar is probing health of dnsmasq, it's not healthy (but don't know why)
I was curious, since neither my busybox nor my master node knew how to reach <IP_ADDRESS> (none of their routing tables (route -n) has effective route to it); I wonder maybe I missed some critical points? Do I need to tune weave network to allow pods and nodes can talk?

Also, can you make sure to use busybox:1.28 there is a problem with busybox:latest which causes the dns lookup to fail.

Thanks Sebastien, I will definitely try that as well.
Will let you & Michael know my finding asap.
Benny
sebgoa<EMAIL_ADDRESS>於 2018年10月10日 週三 上午3:41寫道：

Also, can you make sure to use busybox:1.28 there is a problem with
busybox:latest which causes the dns lookup to fail.
—
You are receiving this because you authored the thread.
Reply to this email directly, view it on GitHub
https://github.com/k8s-cookbook/recipes/issues/2#issuecomment-428324378,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AlDjxjr737a_z_820bJo_ucNT_4zgYofks5ujPwBgaJpZM4XSE0T
.

Good news
Although I installed Docker 1.12.6-cs13 but still got same busybox/dns query error
However, using busybox v1.28.4 did get rid of my pain (yapee~)

Appreciate you two kind gentlemen to show me a working path


Stylelint upgrade

Deprecate media-feature-no-missing-punctuation https://github.com/alienlebarge/stylelint-config/issues/19
'rule-non-nested-empty-line-before' has been deprecated and in 8.0 will be removed https://github.com/stylelint/stylelint/issues/2075 - a new rule has been introduced: rule-empty-line-before, have to figure out the correct configuration.

There are two conflicting rules:
    "rule-empty-line-before": [ "always-multi-line", {
      except: [ "first-nested", "inside-block-and-after-rule" ],
      ignore: [ "after-comment" ]
    } ],

and
"selector-list-comma-newline-after": "always",

This second configuration should allow structures like:
  h1,
  h2,
  p,
  input,
  a {
    line-height: 1.3;
  }

but I found no way to configure the first to not prevent them. I ended up adding "inside-block" to the ignore list which is to broad in my opinion.


common: add promise support

RE: https://github.com/GoogleCloudPlatform/google-cloud-node/pull/1142

U

Coverage decreased (-0.02%) to 99.984% when pulling 2542a4226519252521956a57524e95f952abdf3c on callmehiphop:promise-common-support into 14565efa7e5f0a4217d920f06a3e95d6108cfb57 on GoogleCloudPlatform:master.

Coverage remained the same at 100.0% when pulling 939af8de937660ae807e41da039958cd34c421df on callmehiphop:promise-common-support into 14565efa7e5f0a4217d920f06a3e95d6108cfb57 on GoogleCloudPlatform:master.


Implement toggle feature for left nav

Fix https://github.com/ipfs/ipfs-cluster-website/issues/91.

Hi @tapaswenipathak ! Thank you for the contribution! I pulled your branch down and tested it locally, and I'm not sure I see where your change is implemented. I think you may have worked off master instead of the new-docs-layout branch. I might be misunderstanding though -- could you add a screenshot of your change in action? Thank you again!

Hello @meiqimichelle: I didn't know new-docs-layout branch exist, rebasing and merging. From the ticket comment I don't think toggle feature is implemented. I just looked at the new-docs-layout branch, correct me if I'm wrong.

Ah, sorry for the confusion! Your contribution came just as I was iterating on the layout, and removing the need for a toggle to simplify everything. I'll open a WIP PR so it's a little clearer what's in progress! :-/

Should I close this PR?

From https://github.com/ipfs/ipfs-cluster-website/issues/91#issuecomment-516192813: should I close this PR?

Hey @meiqimichelle! Can you let me know if you are done with implementing the feature, I can then close the PR.


Support .env files & major refactoring of argument parsing

Hey there! First, thanks for the script!
I wanted to add (local) logging, but before I hacked on it I figured I'd add support for .env files and clean up the argument parsing a bit. I tried not to change the semantics but I haven't thoroughly tested yet.
What I've got is a pretty major refactor that's just one commit behind your repo's status.
https://github.com/AndrewPardoe/tmo-monitor/blob/config/tmo-monitor.py
If you like the refactor, I'm happy to integrate your multiple ping logic & submit a PR to merge everything back. If you don't like the refactor, I'll probably maintain a fork. I'm still testing so I haven't created a PR yet.
Please LMK.

By the way, my usage is to only reboot if the ping fails (so your multiple tries on the ping logic is nice.)
The log format I'm thinking of is to always check the connection stats and log when they change. Also, log when ping fails and the modem reboots.
For example:
2021-12-02 11:35:00   4G: B2 5G: n41 Ping: 75ms
2021-12-02 11:36:00   4G: B66 5G: n41 Ping: 80 ms       # logged due to 4G band change
2021-12-02 11:40:00   4G: B2 5G: n41 Ping: 100ms        # logged due to 4G band change
2021-12-02 11:40:00   4G: B2 5G: n41 Ping: failed ***REBOOTING***

@AndrewPardoe thanks for sharing - I am glad you are finding value in the script. I prefer supporting your changes so everyone can benefit and your work can maintained long-term. To adhere to semantic versioning and to anticipate differences in output based on the introduction of logging, I think this calls for a version bump to 2.0.0 once merged and released.
I already wanted to add support for .env files and for logging, so this is great. Let's aim to ensure that there's feature parity and hopefully the notation in the .env file can be as close as possible to the command line arguments to be easily understood in isolation without relying too heavily on the placeholder values.
I had a chance to start reviewing your changes before you rewrote the history after my upstream commit, and saw you namespaced the config values to avoid inherited values like USERNAME causing conflicts.
I think logging the reason for reboots is helpful as demonstrated in your example so it can serve as a proper audit trail. I do want to make sure that people don't need to resort to scraping their logs to analyze changes over time, so in the spirit of #11 hopefully this can eventually evolve to appending stats to a CSV or similar location (in theory the serialization format should be pluggable).
Naturally, we'd still want the sort of logging you've shown.
In terms of "reboot on X", I do think it may be nice to have a more declarative set of configuration (through the .env and/or flags), so giving this release a major version bump should give some freedom to changing defaults vs what was necessary for backwards compatibility up to this point when I was bolting on additional functionality.
Namely, I think the script should not have opinionated defaults to the point where the user has to specify tons of configuration to undo defaults that don't suit common use cases. I also believe that the user shouldn't be surprised by what it is doing.
Probably the most neutral thing the script can do is check for bands (preferring none) and signal metrics, maybe perform a ping, possibly log the results, and then exit.
Let me know if you plan to add any extra polish, but I think for sure your work is welcome and can be merged in rather than staying separate.

Sounds good! Let me finish up the testing this week and I'll prepare a PR. I've got a few busy days at work ahead but I should be able to finish this week.

@highvolt-dev, I've cleaned this up a bit, tested, and I think I'm ready to make a PR. You can peek here: https://github.com/AndrewPardoe/tmo-monitor/tree/config
Should I PR a separate v2 branch or just PR on main?

PR is #23

Fixed by #23


Fix test failures on SAP HANA.

Skip org.hibernate.test.annotations.query.QueryAndSQLTest.testNativeQueryWithFormulaAttributeWithoutAlias
Update HANA JDBC driver to fix org.hibernate.test.type.LocalDateTimeTest

Thanks @breglerj ! I'll create a JIRA to track these.

rebased & merged as https://hibernate.atlassian.net/browse/HHH-13553

P.S. sorry I didn't warn you, CI has been down for a while as we did some maintenance.


add longitude and latitude to UserGetDTO

Created an issue for safety issue

For the moment it is okay, but this is a big safety issue that evey user can get the exact location of every other user, since GET /users/userId only checks for general access.

sorry, did not noticed that get user is only general access. should i do a seprat get method onyl for lng and lat?

For the moment it is okay, but this is a big safety issue that evey user can get the exact location of every other user, since GET /users/userId only checks for general access.

sorry, did not noticed that get user is only general access. should i do a seprat get method onyl for lng and lat?

Not needed anymore.


style: Enforce mypy no-implicit-optional setting

Which has been introduced in mypy==0.981 and enforce proper type annotations for args / kwargs with default None value.

Coverage decreased (-0.004%) to 97.141% when pulling 20df29fb0c0600e6c5642f94860338375c0f1add on style/mypy-no-implicit-optional into d96a47f7b65394f5aeeadd25bba904c840d95acc on main.


Wrong link for language tools in README

Wrong link for language tools

Duplicate of https://github.com/fnando/vscode-linter/pull/9


How to use crontab

Hey guys,
i like this boilerplate but i dont know to configure crontab.
I read the issues here in the repo but i dont get it to work and i didnt find any logs.
i tried these 4 variants
# m h  dom mon dow  user  command
*/10 * * * * application . ~/.profile; /usr/local/bin/php /app/bin/console app:proxy:import
* * * * * application . ~/.profile; /usr/local/bin/php /app/bin/console app:proxy:check
*/5 * * * * application . ~/.profile; /usr/local/bin/php /app/bin/console app:haproxy:dump

# m h  dom mon dow  user  command
*/10 * * * * application /usr/local/bin/php /app/bin/console app:proxy:import
* * * * * application /usr/local/bin/php /app/bin/console app:proxy:check
*/5 * * * * application /usr/local/bin/php /app/bin/console app:haproxy:dump

# m h  dom mon dow  user  command
*/10 * * * * /usr/local/bin/php /app/bin/console app:proxy:import
* * * * * /usr/local/bin/php /app/bin/console app:proxy:check
*/5 * * * * /usr/local/bin/php /app/bin/console app:haproxy:dump

# m h  dom mon dow  user  command
*/10 * * * * php /app/bin/console app:proxy:import
* * * * * php /app/bin/console app:proxy:check
*/5 * * * * php /app/bin/console app:haproxy:dump

What is wrong?
Can anyone please help?
Thank you very much.

Full example:
Dockerfile
FROM webdevops/php-nginx:7.2
RUN docker-service-enable cron
COPY etc /opt/docker/etc

etc/cron/crontab
SHELL=/bin/bash

# m h dom mon dow   user   command
* * * * * application /usr/local/bin/php /app/bin/console sw:cron:run

The logs are redirected to stdout by supervisord (which runs all applications in the container). Therefore you're able to see the cron logs by doing docker logs -f app_container.
For production context you can e.g. use logstash to extract the cron logs from the docker log stream and show them separately.

Hey, I just created an example of how to use crontab with webdevops docker-compose, you can check it our here:
https://github.com/abagayev/docker-bootstrap-collection/tree/master/crontab-in-container


[TASK][EASY] JDBC Engine supports StarRocks

Code of Conduct

[X] I agree to follow this project's Code of Conduct

Search before creating

[X] I have searched in the task list and found no similar tasks.

Mentor

[ ] I have sufficient knowledge and experience of this task, and I volunteer to be the mentor of this task to guide contributors to complete the task.

Skill requirements

Basic knowledge of Scala programming language
Basic knowledge of JDBC concepts
Basic knowledge of Docker and Testcontianers

Background and Goals
Currently, Kyuubi supports JDBC engines with limited dialects, and we can extend the dialects to support StarRocks, which is an open-source and high-performance analytical database.
Reference https://www.bilibili.com/video/BV1UT411m7LR
Implementation steps

Implement a StarRocks dialect in the JDBC engine
Leverage the Testcontainers to add integration tests
Update document correspondingly

Additional context
No response

@pan3793 could this issue be added to the task list of Code Contribution Program?

@banmoy thanks, task was added to the list

Thanks a lot :smiley:

@banmoy would you like to complete it by yourself, or leave it to other contributors?

@pan3793 Hello, I have strong interests on it and during my daily work, Apache Kyuubi and StarRocks are two most useful tools. I think it can be finished in 7 days! please aisgn it to me~thx

@phionex0571 Emm... you have been assigned 2 tasks, do you have sufficient free time to take the third and complete them in parallel?

@phionex0571 Emm... you have been assigned 2 tasks, do you have sufficient free time to take the third and complete them in parallel?

@pan3793 Yeeep, in the previous year, I'd finished a StarRocks proxy in Apache Kyuubi 1.4, but that was not elegant and that was imitated like Apache Doris Engine implementation in Apache Kyuubi. And it's applied by 3 applications in production environment of my company. I hold strong belief that I'm able to finish this issue in time.

Let's assign this task to both @phionex0571 @banmoy first.
Please raise the subtasks for this task. Small subtasks and improvements are always welcomed.
@phionex0571 please feel free to ask @banmoy about details of StartRocks, since he is from StarRocks team and has professionalism in Spark/Flink connector as well.
Also cc @zhaomin1423, the original contributor of the JDBC engine. They may need some guidance for this task.
Thanks to all.

Let's assign this task to both @phionex0571 @banmoy first. Please raise the subtasks for this task. Small subtasks and improvements are always welcomed. @phionex0571 please feel free to ask @banmoy about details of StartRocks, since he is from StarRocks team and has professionalism in Spark/Flink connector as well.
Also cc @zhaomin1423, the original contributor of the JDBC engine. They may need some guidance for this task.
Thanks to all.

Thanks you all, Starrocks is excellent ans used widely, look forward.

Let's assign this task to both @phionex0571 @banmoy first. Please raise the subtasks for this task. Small subtasks and improvements are always welcomed. @phionex0571 please feel free to ask @banmoy about details of StartRocks, since he is from StarRocks team and has professionalism in Spark/Flink connector as well.
Also cc @zhaomin1423, the original contributor of the JDBC engine. They may need some guidance for this task.
Thanks to all.

Thanks you all, Starrocks is excellent ans used widely, look forward.

@bowenliang123 Hi, I've finished almost all the coding work and I have a question about StarRocks version in test cases. There're
several versions of StarRocks and which one should I choose to design unit tests, is it reasonable to use StarRocks 2.5.13? or 3.x?

@phionex0571 Is it possible to make the unit tests run against the latest several StarRocks versions, such as 2.5, 3.0, and 3.1? So that we can tell users in the doc which version of StarRocks is supported, just like Spark/Flink/Trino? I think test cases should be same among different versions, but just use the specific docker image for each version?

@banmoy It's not suggested to tested on multiple versions of StarRocks. As for other engines for Spark/Flink/Trino, we tested on different matrix combinations as Kyuubi use different version of API on these engines and has dedicated engine implementation and adaptations.
But as StarRocks introduced no major FE feature or breaking changes in protocol or dialect between 2.x and 3.x, and the JDBC engine uses the same version of Mysql Driver for connection, it's reasonable to test only on the latest stable version.

@phionex0571 Hi, is there any progress on this task?

@banmoy StarRocks support of dialects/connection/tests in the JDBC engine has been introduced in PR 5882 (https://github.com/apache/kyuubi/pull/5882), if you may be concerned. Have check or validation on it.


fix: persistent page-level targeting values

Description
This PR fixes an issue where old page-level targeting values are not getting removed from googletag.pubads() when the ad config that gets passed into AdvertisingProvider updates. What this mean is that when targeting values are removed from your ad config, they still persist in googletag.pubads().
The fix is to call pubads.clearTargeting() to clear all previous targeting values before calling pubads.setTargeting(key, value) to pass in the updated targeting values.

:tada: This PR is included in version 4.2.8 :tada:
The release is available on:

GitHub release
npm package (@latest dist-tag)

Your semantic-release bot :package::rocket:


Added POUF description to the home page

I added a description of how the deployment considerations can be used in the creation of POUFs.

This has been reviewed. Ok to merge?


seekTo doesn't work when called before play

In the Vimeo player at least, calling seekTo after initializing the player has an unexpected result.
Expected result: player will skip to passed frame, while remaining paused.
Actual result: player starts playing from beginning.

I'm seeing similar behavior with the file player using dash files.

This has been half-fixed by 6ddb523f2e97ef9c03e581cc8a58908f2b36f9f8, although the setCurrentTime method in the vimeo player API will automatically play the video after seeking. The only way to prevent this on ReactPlayer's side would be to pause immediately after seeking, maybe using the onSeek prop.
Also, keep in mind that there are many existing issue with the vimeo player and setCurrentTime.


Docker swarm

I added the Support to enable a docker-swarm by Setting the flag $docker_swarm to true. If this flag is set, the following Settings are set while provisioning:

Port 3375 in the first instance is forwared to the same port on the host
Shell scripts are added to deploy the docker-swarm agent on all instances and the docker-swarm manager on the first instance

I am extremely hesitant to accept this patch. As I understand it, Docker swarm will not work with CoreOS automatic updates (I was told version skew is not handled yet). I would hate to make it easy for an unknowing user to shoot themselves in the foot.


chore(deps): update typescript

This PR contains the following updates:

Package
Type
Update
Change

@types/chai (source)
devDependencies
patch
4.3.12 -> 4.3.14

@types/node (source)
devDependencies
patch
20.11.28 -> 20.11.30

@types/node (source)
dependencies
patch
20.11.28 -> 20.11.30

gdata-vaas
dependencies
patch
6.2.2 -> 6.2.3

typescript (source)
devDependencies
patch
5.4.2 -> 5.4.3

typescript (source)
dependencies
patch
5.4.2 -> 5.4.3

Release Notes

GDATASoftwareAG/vaas (gdata-vaas)
v6.2.3
Compare Source

Microsoft/TypeScript (typescript)
v5.4.3: TypeScript 5.4.3
Compare Source
For release notes, check out the release announcement.
For the complete list of fixed issues, check out the

fixed issues query for Typescript 5.4.0 (Beta).
fixed issues query for Typescript 5.4.1 (RC).
fixed issues query for Typescript 5.4.2 (Stable).
fixed issues query for Typescript 5.4.3 (Stable).

Downloads are available on:

NuGet package

Configuration
:date: Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).
:vertical_traffic_light: Automerge: Disabled by config. Please merge this manually once you are satisfied.
:recycle: Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.
:ghost: Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.

[ ] If you want to rebase/retry this PR, check this box

This PR has been generated by Renovate Bot.

Edited/Blocked Notification
Renovate will not automatically rebase this PR, because it does not recognize the last commit author and assumes somebody else may have edited the PR.
You can manually request rebase by checking the rebase/retry box above.
:warning: Warning: custom changes will be lost.


Fix akamai-open/AkamaiOPEN-edgegrid-node#14.

Removed console.log() statement.

Actually this is already being dealt with in #13.


Add to client module ability to retrieve metadata from runs

First version implemented in https://github.com/simvue-io/client/pull/57
Will probably need improvements to simplify user experience, e.g. directly obtaining run metadata as dataframes etc.

Now support dataframe output: https://github.com/simvue-io/client/pull/65/files

Closing for now as we have at least an initial version of this.


[Request] THE LEGEND OF ZELDA - Twilight Princess HD

Some basic cheat functions like infinite hearts, arrows, bombs, etc.

Duplicate listing, will go ahead and close it

Duplicate listing, will go ahead and close it

Not a duplicate. This request is for Twilight Princess HD and #488 is for Wind Waker HD.

Not a duplicate. This request is for Twilight Princess HD and #488 is for Wind Waker HD.

Your right, I didn't notice that. I'll have it re opened.


Don't replace URL in pages that are already English

Currently, we're sending an URL update for English pages to the browser. It changes nothing, but could be potentially avoided.

Closed by #17.


[Bug]: Appsmith Backup Runs Every Day With APPSMITH_BACKUP_CRON_EXPRESSION=disable

Is there an existing issue for this?

[X] I have searched the existing issues

Description
The Appsmith backup runs every day event though the user is using the expression APPSMITH_BACKUP_CRON_EXPRESSION=disable.
Front thread for more details.
Steps To Reproduce

Set the expression APPSMITH_BACKUP_CRON_EXPRESSION=disable.
Restart Appsmith.

Public Sample App
No response
Environment
Production
Issue video log
No response
Version
self-hosted

This issue is resolved


[BUG] ERROR: Cannot install urllib3==2.0.4 because these package versions have conflicting dependencies.

What is the bug?
ERROR: Cannot install -r requirements.txt (line 28) and urllib3==2.0.4 because these package versions have conflicting dependencies.
The conflict is caused by:
The user requested urllib3==2.0.4
opensearch-py 2.3.1 depends on urllib3<2 and >=1.21.1
How can one reproduce the bug?
When try to install new version of URLLIB3
What is the expected behavior?
The latest lib of urllib3 is 2.0.4

Hello @vchepurko,
The issue has been resolved in PR #466, but it has not been released yet. If necessary, kindly create an issue for the release of version 2.3.2. Thank you :)


Italian translation partially working

when I run it.wttr.in/milano?format=%C I often get values in English

Same thing for many languages, same problem in french:  https://github.com/chubin/wttr.in/issues/963


Remove appearance from textarea

This line was added to make inputs and textareas have the same border, but it seems it has a lot of unexpected side effects and support will be removed by the end of the year.
Closes https://github.com/twbs/bootstrap/issues/29430

No backport?

No, I added that in the latest reboot changes.

I contacted GH Support regarding the Ci not firing up.

Never received a reply from support, but this should be fixed now anyway.

I've rebased the PR, tests are running now.

Yeah but there's another bug that the merge button is disabled even with approvals and checks passing.
I sent them an email, but at this point, I doubt I'll get a reply :P


"You have unsaved changes" message keeps popping

OS: Ubuntu 16.04
PyQt version: 5.14.2

I just started using the tool.
I get an annoying You have unsaved changes, proceed anyway? message whenever I browse pictures.
I just loaded the images directory, loaded the annotations directory using Change Save Dir, the BBs are shown fine, but once in several pictures while I browse I get the above message.
Needless to say I haven't touched anything.
What am I doing wrong here?
Edit:
Investigating further, I compared the XMLs before I load them and after I load and save them (even though I perform no change in the program itself).
I find that the database tag is swithced to Unknown, several bounding boxes are changed by 1 pixel, and some objects truncated tag is being turned on to 1 from 0, even though I did NOT touch anything in the GUI, just loaded the images.

@CodeJjang you can auto save your annotation by clicking in "auto save mode" in the view in the top bar

The thing is I don't ant to auto save it, I haven't touched anything and it
keeps popping up.
On Wed, Aug 19, 2020 at 12:14 PM AnhPC03<EMAIL_ADDRESS>wrote:

@CodeJjang https://github.com/CodeJjang you can auto save your
annotation by clicking in "auto save mode" in the view in the top bar
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/tzutalin/labelImg/issues/595#issuecomment-676005175,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/ACCJOD7NUEB7XKMDQQQZZM3SBOJYBANCNFSM4NH7O6LA
.

@AnhPC03 The thing is I don't want to auto save it, I haven't touched anything and it keeps popping up.

@CodeJjang can you show me terminal screen when you labeled?

@CodeJjang can you show me terminal screen when you labeled?

I get the same problem.

Do you have any ideas?

@CodeJjang can you show me terminal screen when you labeled?

I get the same problem.

Do you have any ideas?

@CodeJjang can you show me terminal screen when you labeled?

I get the same problem.

Do you have any ideas?

Do you annotate that image with special label? What was your label?

@CodeJjang can you show me terminal screen when you labeled?

I get the same problem.

Do you have any ideas?

@lyk7539511 Do you annotate that image with special label? What was your label?

I am using Chinese as a label.

@CodeJjang can you show me terminal screen when you labeled?

I get the same problem.

Do you have any ideas?

@lyk7539511 Do you annotate that image with special label? What was your label?

I am using Chinese as a label.

@lyk7539511 You can not use special characters as label in this tool. I think your label had some special characters. Check it again.

The solution for new users like me who get this error:
"open dir" and "change save dir" folder names should use English letters. This will solve the problem.


New progress bar for unknown amount of iterations in advance

Added a new progress bar for infinite (unknown max) iterations.
Added a test for it in test_progress.py

edited relevant README.rst section

Hi, this is very interesting, but the implementation can be simplified a lot. You can implement an AdaptiveMixin that overrides percent and progress. Then AdaptiveBar can become a one liner:
class AdaptiveBar(AdaptiveMixin, IncrementalBar): pass

That way you can make any of the existing bars become adaptive.

ACK, will change the implementation...
Would you prefer that as a new PR or keep working on this?

Let's keep working on this one for now and see if we can squash the commits in the end.


Grid gutter width

Is there any gutter width for grid, how to give space between grids, is there any solutions...

@cvaraj Not sure what you mean here without a little more information but the col class already provides padding to the left and right of a div with that class applied.
.row .col {     float: left;     box-sizing: border-box;     padding: 0 0.75rem; }
This should provide the gutter between columns within a row. If you provide more information I can clarify/correct my answer

The gutter width can be altered in our Sass variables file. Or you can override the padding like @stap123 showed above

thank you @stap123 and @acburst  i understood ..


Test Fwk: Add ScMap ordering constraints or helper fn for creating ordered map

We need a way to create an ScMap that adheres to the ordering requirements, so that when a user builds a map it is ordered which means it can be ed25519 signed in the same way that a contract would sign.
This showed up in @jonjove's testing as a major pain point for building maps to submit to contracts.

Duplicate of https://github.com/stellar/rs-stellar-xdr/issues/98