Proposal: 'typeon' operator

Proposal: 'typeon' operator
References the type associated with an interface or class property, but in contrast to typeof, refers to it through the containing Type itself. i.e. directly queries the type set on the property rather than the type of an instance of it:
interface MyInterface {
	prop: number;
}

let val: typeon MyInterface.prop; // type of val is 'number'

This would work with any property, including ones contained in anonymous and nested interfaces:
interface MyInterface {
	obj: {
		x: number;
		y: number;
	}
}

let myX: typeon MyInterface.obj.x; // type of myX is now number

Generic interfaces:
interface MyInterface<T> {
	obj: {
		x: T;
		y: T;
		func: (arg: T) => T;
	}
}

let f: typeon MyInterface<number>.obj.func; // type of f is now (arg: number) => number

It would be possible to reference the property types at any scope, including within the referenced interface itself:
interface MyInterface {
	val: string;
	anotherVal: typeon MyInterface.val;

	obj: {
		x: number,
		y: number;
		func(arg:number): typeon MyInterface.obj.x;
	}
}

A special this type reference could be supported for this very purpose (this would be scoped to the closest containing interface, and that would also apply to anonymous ones):
interface MyInterface {
	val: string;
	anotherVal: typeon this.val;

	obj: {
		x: number,
		y: number;

		// Note: 'this' is scoped to the anonymous interface here.
		// 'typeon this.val' would give an error.
		func(arg: string): typeon this.x;
	}
}

Would also be possible in interfaces declared through type and purely anonymous ones:
type MyType = {
	name: string;
	age: number;
	query: (username: typeon this.name) => typeon this.age;
}

let test: { x: number, y: typeon this.x }

And to classes, which would also include references to the types of properties declared in base classes when using this (if that would be problematic, it is possible to use super as an alternative):
class UserBase {
	id: string;
}

class User extends UserBase {
	age: number;

	chatWithUser(id: typeon this.id): { id: typeon User.id, age: typeon User.age } {

		// The first argument for 'chatWith' is expected to be a string here, so this works.
		chatWith(id);
		..
	}
}

Using these ad-hoc references would make it easier to express of the semantic intention for the usage of the type, and automatically "synchronize" with future changes to the type of the referenced property. This both reduces effort and prevents human errors:
class UserBase {
	// The type for 'id' has now changed, this usually means that all similar
	// semantic usages of it would need to be manually checked and updated,
	// this includes ones in derived classes.
	id: string | number;
}

class User extends UserBase {
	age: number;

	// The type of the 'id' argument and anonymous interface property has
	// automatically synchronized with the one set in the base class!
	// This ensures that they will always be consistent and will propagate type errors
	// into the body of the function.
	chatWithUser(id: typeon this.id): { id: typeon User.id, age: typeon User.age } {

		// The first argument for 'chatWith' is expected to be a string here,
		// but now the type of 'id' has changed to string | number so will error.
		// This compile-time error is possible because the type was referenced with 'typeon'
		chatWith(id); // Error! type 'string' is not assignable from 'string | number'
		..
	}
}

It is also possible to "reuse" this syntax to reference the type of a class instance (typeof MyClass only gives the type of the constructor):
class MyClass {
	instanceProp: number;
	static staticProp: string;

	constructor(arg: boolean) {
		..
	}
}

let a: typeof MyClass; // 'a' now has type { staticProp: string, new (arg: boolean) }

let b: typeon MyClass; // 'b' now has type { instanceProp: number }

Equivalent reduction to named type aliases
This can be internally implemented in the compiler like this:
Source:
interface MyInterface {
	val1: string;
	val2: typeon this.val1;
	val3: typeon this.val2;

	obj: {
		x: number,
		y: number;

		func(arg: string): typeon this.x;
	}
}

Reduction:
type TypeOn_val1 = string;
type TypeOn_val2 = TypeOn_val1;
type TypeOn_val3 = TypeOn_val2;

type TypeOn_obj_x = number;
type TypeOn_obj_func_returnType = TypeOn_obj_x;

type TypeOn_obj = {
	x: TypeOn_obj_x;
	y: number;

	func(arg: string): TypeOn_obj_func_returnType;
}

interface MyInterface {
	val1: TypeOn_val1;
	val2: TypeOn_val2;
	val3: TypeOn_val3;

	obj: TypeOn_obj;
}

Example with generic interfaces:
Source:
interface MyGenericInterface<T> {
	val1: T;
	val2: typeon val1;

	obj: {
		a: Array<T>,

		func(arg: T): typeon this.a;
	}
}

Reduction (this uses the new generic type alias declarations. Compiles and works in 1.6 Beta):
type TypeOn_val1<T> = T;
type TypeOn_val2<T> = TypeOn_val1<T>;

type TypeOn_obj_a<T> = Array<T>;
type TypeOn_obj_func_returnType<T> = TypeOn_obj_a<T>;

type TypeOn_obj<T> = {
	a: TypeOn_obj_a<T>;

	func(arg: T): TypeOn_obj_func_returnType<T>
};

interface MyGenericInterface<T> {
	val1: TypeOn_val1<T>;
	val2: TypeOn_val2<T>;

	obj: TypeOn_obj<T>;
}

Possible issues and their solutions
Detect and error on circular references:
interface SelfReferencingPropertyType {
	x: typeon this.x; // Error: self reference
}

interface EndlessLoop {
	x: typeon this.y; // Error: indirect self reference
	y: typeon this.x; // Error: indirect self reference
}

This would happen automatically through the reduction described above. The error currently reported through type is "Error: type 'TypeOn_EndlessLoop_y' circularly references itself".
Current Workarounds
It is currently possible to partially emulate this using typeof with a "dummy" instance of the type:
interface MyInterface {
	obj: {
		x: number,
		y: number
	}
}

let dummy: MyInterface;

let val: typeof dummy.obj;

And, surprisingly, even:
interface MyInterface {
	obj: {
		x: number,
		y: typeof dummy.obj.x;
	}
}

interface AnotherInterface {
	func(arg:number): typeof dummy.obj;
}

var dummy: MyInterface;

But requires a globally scoped variable, less clear on semantics (what is dummy?) and would look out-of-place in declaration files. It also doesn't support keywords like this (and possibly super if needed) so it cannot support anonymous types. For generics it is not possible propagate the scope's generic parameter value. Other challenges may present in practice.
[Originally proposed in this issue]

Can the typeof operator not be extended to support these cases?

Can the typeof operator not be extended to support these cases?
I believe it would be ambiguous for classes:
class C {
    static prop;
    prop;
}

var p: typeof C.prop;

Obviously introducing another keyword is icky, especially for a bit of an edge case.  For the class use case, the following would seem logical to me:
class C {
    static prop: number;
    prop: string;
}

let p: typeof C.prop = 'foo'; // p typeof string
let q: typeof typeof C.prop = 1; // q typeof number

A more practical example to demonstrate its real-world usefulness:
Encapsulate and reference anonymous types (through the equivalent of "auto-aliasing") in a class or interface without needing to declare additional external type aliases or interfaces. This allow a different style of coding:
class Process {
	id: number;

	state: {
		memoryUsage: {
			real: number;
			virtual: number;
			private: number;
		};

		processorUsage: Array<{ index: number, percentage: number }>;
	}

	constructor() {
		...
	}
	..
}

class OSQuery {
	static queryMemoryUsage(id: typeon Process.id): typeon Process.state.memoryUsage {
		return {
			real: OS.getRealUsage(id),
			virtual: OS.getVirtualUsage(id),
			private: OS.getPrivateUsage(id)
		};
	}

	static queryProcessorsUsage(id: typeon Process.id): typeon Process.state.processorUsage {
		result: typeon Process.state.processorUsage;

		for (let i=0; i< OS.processorCount; i++) {
			result.push( { index: i, percentage: OS.getProcessorUsage(id, i) })
		}

		return result;
	}

	static queryProcessState(id: typeon Process.id): typeon Process.state {
		return {
			memoryUsage: queryMemoryUsage(id),
			processorUsage: queryProcessorsUsage(id)
		}
	}
	..
}

In the conventional style of coding, 4 auxiliary interfaces or type aliases would need to be declared here: ProcessID, ProcessState, ProcessMemoryUsage, ProcessProcessorUsage.

@DanielRosenwasser , @danquirk:
Actually you can do these type deductions already, using a type inference hack. That means the type system can already do it, so it is really syntactic support which is required:
class MyClass {
    instanceProp: number;
    static staticProp: string;

    constructor(arg: boolean) {
       // ..
    }
}

    function func<T>(a: T): { a: T } { return { a: a }; };

    // a has type string. This works today using typeof syntax.
    let a: typeof MyClass.staticProp = "";

    // Typeof doesn't work with instance properties, but type inference can still deduce the type.
    // b has the type number.
    let b = false ? (<MyClass>(void 0)).instanceProp : void 0;

    // c has type {a: number}.
    // Again, type inference can deduce the type without evaluating the expression
    let c = false ? (func(<number>(void 0))) : void 0;

Proposal: Allow arbitrary expressions as argument to typeof. These "type expressions" would not be evaluated, only the type deduction would take place at compile time.
If typeof accepted arbitrary expressions instead of identifiers, this would meet the need, I think.
class MyClass {
    instanceProp: number;
    static staticProp: string;

    constructor(arg: boolean) {
       // ..
    }
}

    function func<T>(a: T): { a: T } { return { a: a }; };

// b has type of the instanceProp property of MyClass.
let b: typeof (<MyClass>(void 0)).instanceProp;
// c has same type as the return value of func(1), (but func is not evaluated).
let c: typeof (func(<number>(void 0)));

Further proposal: Allow (<typename>) as a shorthand for (<typename>(void 0)) within a type expression. This would simplify writing type expressions for such uses as @rotemdan describes. so typeof func(<number> 10).a could be written typeof func(<number>).a

Proposal: Allow arbitrary expressions as argument to typeof. These "type expressions" would not be evaluated, only the type deduction would take place at compile time.

I agree with this approach. It solves all the cases mentioned here. It handles anonymous types. It's not ambiguous with classes:
class C {
    static prop;
    prop;
}

var pStatic: typeof C.prop;
var pInstance: typeof new C().prop;

And the compiler can already do this, it just doesn't expose the ability. This would just remove its limitations.
C++ has exactly this operator, it is called decltype and it maps an expression to a type without evaluating the expression. Given the limitations currently placed on typeof, it could be extended to work just like decltype without a breaking change. It would become far more useful.

@yortus, @benliddicott
A main goal and benefit of the approach I presented is to allow a clean and natural way to reference into nested anonymous types like is demonstrated in this previous comment. Without a concise and readable syntax that would not generally be a practical thing to do. It was designed with the full intention of becoming a mainstream and usable pattern, not just an "advanced" feature or a trick which would be mostly known and used by experienced developers.
Another benefit is the addition of the this "type", which for generic types would also mean propagating the generic parameter of the current scope to get an even cleaner syntax:
class Process<T> {
  options: {
    priority: number;
    type: T;
    relatedProcesses: {
      parentProcess: typeon this;
      subProcessess: Array<typeon this>;
    }
  }
  constructor(options: typeon this.options) {
    ..
  }
}

Using typeof expression, it would look like this:
class Process<T> {
  options: {
    priority: number;
    type: T;
    related: {
      parentProcess: typeof (new Process<T>);
      subProcessess: Array<typeof (new Process<T>)>;
    }
  }
  constructor(options: typeof ((new Process<T>).options)) {
    ..
  }
}

I understand the need for a more powerful operator, and using expressions would achieve that, but that wouldn't automatically make it more useful for these cases or for other more specific needs (such as returnTypeOf for example), so I think these are mostly unrelated proposals.

@rotemdan I think most people would write your last example like this:
class Process<T> {
    constructor(public options: ProcessOptions<T>) {
        ...
    }
}

interface ProcessOptions<T> {
    priority: number;
    type: T;
    relatedProcesses: {
        parentProcess: Process<T>;
        subProcessess: Array<Process<T>>;
    }
}

Is it really such a pain point to declare the ProcessOptions interface that a new syntax is needed? Note the other two uses of typeon in your example (inside the options interface) aren't needed at all.

@yortus
You're right, I noticed it when I wrote it but I guess it was shown mostly to demonstrate how something equivalent would achieved specifically with that approach (and specifically for generic classes or interfaces), which at that case wasn't really better than just writing the names themselves.
The example in this comment better demonstrates the effect of being able to reference directly into nested anonymous types. With the common approach, every level of the type would need to be declared in its own interface or type alias, so instead of just stating:
state: {
  memoryUsage: {
    real: number;
    virtual: number;
    private: number;
  };

  processorUsage: Array<{ index: number, percentage: number }>;
}

The programmer would need to break it down to something like:
interface ProcessorUsageEntry {
  index: number;
  percentage: number;
}

interface MemoryUsage {
  real: number;
  virtual: number;
  private: number;
}

type ProcessorID = number; // aliased in case that associated type changes

interface ProcessState {
  id: ProcessorID;
  memoryUsage: MemoryUsage;
  processorUsage: Array<ProcessorUsageEntry>
}

I wouldn't necessarily describe this as a "pain point", maybe something that most programmers feel is necessary as they aren't aware of alternative approaches (when appropriate, of course, I mean, not all cases benefit from this), maybe because this was never expressible in the language, and perhaps not in other ones as well (I'm not aware of other languages with an equivalent feature, but I guess I'm not deeply familiar with that many languages).

@rotemdan fair enough. I guess the deeper the anonymous nesting goes, the less difference in effort there is between
typeon Process.state.processorUsage
and
typeof new Process().state.processorUsage

@rotemdan , You are right to identify anonymous types as an important thing to enable.
I think the "typeof expression" approach can handle anonymous types - it's not quite as clean but almost. Instead of:

typeon Class.prop1.prop2.prop3

You would write one of the following:

typeof (<Class>{}).prop1.prop2.prop3 with no loss of function. Or alternatively
typeof new Class().prop1.prop2.prop3

In addition, it could be used in more ways than typeon. For example:
function Blah(): {a: number, b: string}{
return {a: 1, b: ""};
}

// Get the type of the return value.
var b: typeof (Blah());

It would also work to generate the correct type for the return value of a generic function, and so on.
All one has to do is construct an expression of the appropriate type. This can be done by writing an expression casting undefined to the desired type (or writing (new Type()) as @yortus does) then using the property accessors.
class Process {
    id: number;

    state: {
        memoryUsage: {
            real: number;
            virtual: number;
            private: number;
        };

        processorUsage: Array<{ index: number, percentage: number }>;
    }

    constructor() {
        //...
    }
    //...
}

class OSQuery {
    static queryMemoryUsage(id: typeof (<Process>{}).id): typeof (<Process>undefined).state.memoryUsage {
        return {
            real: OS.getRealUsage(id),
            virtual: OS.getVirtualUsage(id),
            private: OS.getPrivateUsage(id)
        };
    }

    static queryProcessorsUsage(id: typeof (<Process>{}).id): typeof (<Process>undefined).state.processorUsage {
        result: typeon Process.state.processorUsage;

        for (let i=0; i< OS.processorCount; i++) {
            result.push( { index: i, percentage: OS.getProcessorUsage(id, i) })
        }

        return result;
    }

    static queryProcessState(id: typeof (<Process>{}).id): typeof (<Process>{}).state {
        return {
            memoryUsage: this.queryMemoryUsage(id),
            processorUsage: this.queryProcessorsUsage(id)
        }
    }
    ..
}// Want the type of state.memoryUsage.virtual
// Has type number
var x: typeof ((<Blah>void 0).state.memoryUsage.virtual) = 0;

// want the type of state.processorUsage[]
// Has type {index: number, percentage: number}
var y: typeof ((<Blah>void 0).processorUsage[0]) = undefined;

// Get the type of the return value.
var b: typeof (Blah());

This would be a killer feature for me. This is an easily filled hole in TypeScript's otherwise great type inference abilities.
For instance, suppose you are writing a function, and you want it to take a parameter of a type, say QueryBuilder, that comes from a third-party library you are interoperating with, say Knex. Unfortunately QueryBuilder only appears as a return value from Knex's functions, and is anonymous.
You could make your own interface QueryBuilder {...} and use structural matching. It has lots of properties and methods so that's pretty painful.
You could modify knex.d.ts to expose its private QueryBuilder and submit a PR to DefinitelyTyped (which is what I did in the end).
Or you could write type QueryBuilder = typeof Knex().select(); and hey presto. I would like that very much.
If an anonymous type only appears in a return position, TypeScript doesn't make it easy to reuse it in an input position. In other words, TypeScript lacks an obvious way of expressing "hey this function's parameter has the same type as that function's return value", even though it can definitely do the inference required. typeof could easily express this and more.

@benliddicott
I understand the need for a more powerful operator, but the main motivation here was to try to get a clean and readable syntax to achieve very specific purpose: allow to reference the types of properties by naturally "dotting" into the containing type, rather than through an instance of it, and to make that an easy and mainstream tool that is as approachable and usable for programmers as much as typeof is.
[I continued my comment at #4233 because it felt a bit off-topic here.]

OK I hadn't seen #4233. TBH, I think that's exactly what is wanted. You are asking for a whole new keyword, and I can't see them going for it when you can just say typeof (<MyClass>{}).property

I'm curious, why is the new keyword needed at all? If it's removed from all the examples above, they will still make sense. For instance, if we have
interface Foo {
  a: number;
  b: string;
}

what's the difference between just Foo and typeon Foo and why would we need to write typeon Foo.a if Foo.a is just as good?
let x: Foo = null; // a common pattern
let y: Foo.a = 0; // this looks just as clear

It seems odd to require the typeon keyword only in the second declaration.

@d180cf
My original proposed syntax was exactly that. The problem was that TypeScript has an edge feature to unify interface and namespace declarations that would make it ambiguous.
Also, to extend the idea to enable referencing class instance types:
class C {
  prop: number;
  static prop: string;
}

Using any one of let x: C.prop (which could also refer to the static property with the same name) or let x: typeof C.prop (which currently refers to the type of the static property) would be ambiguous so a new keyword (or at least an alternative syntax) was necessary. Since the semantics are very similar to typeof it felt reasonable to use something that would look similar. The best that I could find was typeon.
The concept of typeon is subtly different than typeof. typeof refers to the type of something "tangible", i.e. a run-time entity or object. typeon is about the type associated with the declaration itself. In the case of classes typeof C is the type of something tangible, i.e. the constructor itself, which is actually a function. typeon C is a "stretch" of the syntax and refers to the instance type associated with the declaration of C (the original idea was only about properties, but that seemed natural and useful to add).
In the case of interfaces, since interfaces are not tangible, it felt more semantically appropriate to use typeon than typeof. Also considering the case where a class implements an interface:
interface SomeInterface {
  a: number
}

class SomeClass implements SomeInterface {
  a: number;
}

It would be more consistent to use typeon with both i.e. typeon SomeInterface.a and typeon SomeClass.a.

Now I think I get it. Wouldn't it be more correct then to write (typeon SomeClass).a since new A.B means new (A.B)?
Also, after I thought about your example in the other thread, I came to the conclusion, that the dot syntax isn't correct and it should be changed to (typeon SomeClass)#a. The typeon operator returns the internal representation of a type which, in case of Function, probably looks like this in tsc:
interface FunctionType extends Type {
  returnType: Type;
  arguments: Type[];
}

It seems obvious, that the type that describes object literals lists the members of an interface in member dictionary or an array of name-value pairs:
interface DictionaryType extends Type {
  members: { [name: string]: Type };
}

What we ultimately want to get is a way to access these internal properties defined someweher in tsc: in this thread we're discussing how to get access to the list of members and in the other thread I mentioned that it would be nice to access the return type. It seems obvious, that the return type and the members cannot be accessed at the same level, via the dot notation. However the following syntax would be free of ambiguities:
namespace ko {
  interface observable<T> {
    (): T; // getter
    (value: T): this; // setter
    subscribe(listener): { dispose(): void };
  }
}

type KN = ko.observable<number>;

var kn: KN;

type KNRT = (typeon KN).returnType; // the type of what kn() or kn(x) would return
type KNS = (typeon KN).members.subscribe; // (listener) => { dispose(): void }

But it's very likely that (typeon T).members.m will be the most commonly used pattern with typeon so it makes sense to introduce a shorter syntax for that. Such a syntax has already been invented to describe interfaces in JS:
Array.from; // the static Array.from(iterable) function
Array#forEach; // each array has the forEach method, but Array.forEach is undefined

This is why I think that (typeon Array)#forEach would be more correct. But then why not to allow an even shorter syntax: Array#from? It's also free of ambiguities. But if this syntax is allowed, then it sort of implies that typeon Array and just Array is about the same thing, which isn't true.

@d180cf
In Typescript, a class has two essentially unrelated types associated with it:

The constructor type.
The instance type.

You're right that perhaps if the goal was to reference the class' instance type through a runtime entity which was not the instance itself, say, with its constructor, the concept of new would need to be taken in account and probably play a major role in the way the it was laid out.
However in the type realm, there's no meaning for new. A type cannot be 'newed'. That has no meaning for a purely declarative construct. The instance type is just a piece of compile-time metadata associated with the name SomeClass, and is not less or more "favored" than the constructor type.  When trying to define something like typeon SomeClass, that doesn't necessarily carry a particular commitment to a runtime syntax or semantics as might be with typeof. It's essentially open-ended. In this case it was designed with the specific goal of referencing a property through a containing type, not a runtime entity. so there's need to require the programmer to use something (typeon SomeClass).prop. SomeClass.prop is just a path specifier, an address token for piece of compile-time type metadata.
The idea was to make it intuitive and familiar to programmers, and to try to 'match' the typeof syntax and semantics as closely as possible. I felt that the dot syntax (and also the this keyword, which is also [intentionally] reused with subtly different semantics) was preferable simply because otherwise nobody will use the feature (and it will probably not be accepted in the first place). It will seem too foreign and obscure with something like #, same with C++ style :: notation. Since it is very similar in concept and effect to typeof, there's no need to make it look more complicated than it actually is.
Using the . notation, on the other hand, does carry a form of commitment. In the mind of the developer, . means a tangible member that can be accessed at runtime. It would be confusing to overload it with a 'virtual' member like a return type, though I agree the semantics don't rule that out.
I considered alternatives to keywords like returnTypeOf and returnTypeOn, one of them of reusing the function call operator () as a signifier for the return type, e.g. , like typeof func() and typeon FuncType(). It has both advantages and disadvantages. I didn't think any one of these was good enough yet for a proposal, and looking to explore more options.

closing in favor of #6606


[fix][opendata] "\n" of "bulk_download_exceeded_filesize" locale

Coverage decreased (-18.7%) to 60.795% when pulling 68b4c2bc5bc525ac06f56fe13fa29a87d75b2bde on sunny4381:fixes/opendata-buld-download-exceeded-filesize into a61df333a78c3b14b43ac83f51ff5d9eca5e0326 on shirasagi:master.


Remove jade

It appears that jade has some security vulnerabilities showing up in npm audit. Unfortunately jade has been deprecated and the project has been renamed as pug so to remediate these vulnerabilities we would need to remove jade from the project and default to pug. This PR does that, removes jade from the templates and and replaces the default view engine with pug. Since pug is just a renamed version of jade that is still being supported the impact is minimal.

Instead, maybe implement as per voted on in #141 for the change of default and leave jade as an option.


feat: Radio, hover pointer

Description
transform cursor into pointer when hovering over radio button
Preview
https://user-images.githubusercontent.com/3367393/151777088-5a807d06-fad5-4447-95eb-b63c258349ed.mp4

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

npm package (@latest dist-tag)
GitHub release

Your semantic-release bot :package::rocket:


explicitly disable signaling on libcurl handle

fixes: https://github.com/Azure/azure-sdk-for-cpp/issues/625

We have request from customer making this option customizable

Can the customer elaborate on why they want this to be customizeable? This change is to prevent a hang, customizing that behavior would leave the customer at risk of a hang

i'm going to ask the customer. But before we have response from them, let's merge this PR first.

How are you going to handle SIGPIPE which will cause the process to exit?
https://curl.haxx.se/libcurl/c/CURLOPT_NOSIGNAL.html

see https://curl.haxx.se/mail/lib-2006-01/0170.html
The problem is actually openssl signaling broken pipe on closed connection. I need to add a work around for that, since we don't want that signal.
This broken pipe is thrown when we are trying to clean a libcurl connection. So it is expected that the connection could be closed already (waiting on connection pool for a while). All we need is to clean all resources, but there is an exception coming from ssl.

How are you going to handle SIGPIPE which will cause the process to exit?
https://curl.haxx.se/libcurl/c/CURLOPT_NOSIGNAL.html

see https://curl.haxx.se/mail/lib-2006-01/0170.html
The problem is actually openssl signaling broken pipe on closed connection. I need to add a work around for that, since we don't want that signal.
This broken pipe is thrown when we are trying to clean a libcurl connection. So it is expected that the connection could be closed already (waiting on connection pool for a while). All we need is to clean all resources, but there is an exception coming from ssl.

okay, then I want to know what your workaround is. I don't know an easy way to handle this signal, especially as a library, changing process-level signal handler might not be a good idea.

No need to apply this fix.
App is working as expected


Bright background in empty table cell.

https://en.wikipedia.org/wiki/Transmission_Control_Protocol

Will have a look, thanks for posting!


Add pre-commit!

 Something for tomorrow.

Okay this should be ready again! Sorry it took so long :) Next up, justfile!


Simple Tasks

Description of the feature request:
Feature requests:
1 >>>
I am trying to develop an application using Gemini but it is not able to do very simple and easy tasks which can be done by a simple Google search.
Example: I asked Gemini "1$ in Rs" but it is not able to give me the answer, whereas other AI models can.

Gemini's response to the same question:

2>>>
Currently, there is no direct method of giving audio as input. So, please add this feature also, so that I can use this feature.
3>>>
Location-based search: I can search in Google Maps for things like "restaurants near me," but Gemini is not able to answer this. I even tried to provide latitude and longitude but it did not work. Other AI models can provide some sort of answer, not super efficient but giving some answer, i.e.,

Gemini's response:

4>>>
Adding documents like CSV, PDF, PPT, etc. There is no direct method for now. We can extract and then feed the data to Gemini, but it's an overhead and can cause errors if Gemini interprets the data incorrectly.
Conclusion:
The biggest plus point of the Gemini API should be that it should be interconnected with other Google services, but for now, it feels very disconnected. Also, it won't provide answers that can be given in one simple Google search.
What problem are you trying to solve with this feature?

Simple tasks which can be done in one simple search.
Audio Input.
Location-based search.
Adding different documents.

Any other information you'd like to share?
No response

please provide some solution because its one of the most important feature of the application.


feat: add scc attachment functionality

Description
Add functionality to create scc attachment in the da.
https://github.com/terraform-ibm-modules/terraform-ibm-scc-da/issues/34
Release required?

[ ] No release
[ ] Patch release (x.x.X)
[ ] Minor release (x.X.x)
[ ] Major release (X.x.x)

Release notes content
Add functionality to create scc attachment in the da.
Run the pipeline
If the CI pipeline doesn't run when you create the PR, the PR requires a user with GitHub collaborators access to run the pipeline.
Run the CI pipeline when the PR is ready for review and you expect tests to pass. Add a comment to the PR with the following text:
/run pipeline

Checklist for reviewers

[ ] If relevant, a test for the change is included or updated with this PR.
[ ] If relevant, documentation for the change is included or updated with this PR.

For mergers

Use a conventional commit message to set the release level. Follow the guidelines.
Include information that users need to know about the PR in the commit message. The commit message becomes part of the GitHub release notes.
Use the Squash and merge option.

merge https://github.com/terraform-ibm-modules/common-dev-assets/pull/955 first

/run pipeline

/run pipeline

reliant on https://github.com/terraform-ibm-modules/terraform-ibm-scc/pull/98

/run pipeline

/run pipeline

/run pipeline

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

GitHub release
v1.8.0

Your semantic-release bot :package::rocket:


Return types shouldn't be overshadowed by parameters for type parameter inference

TypeScript Version:  3.7.0-dev.20190905

Search Terms: return type type parameter inference infer generic overshadow parameter overshadows return type inference
Code
declare function Mutate<T>(callback: (a: T, b: number) => T): T;
Mutate((a, b) => b);

Expected behavior: assume T is typeof b, which is number
Actual behavior: T defaults to unknown
Another interesting thing about this example is that if you pay attention to the TS tooling, it detects T as number when you first type => b. However, once it re-evaluates the entire statement it thinks T is unknown. I don't know the inner workings of TS, but I guess that when I typed => b TS was waiting for me to make a better indication of what T is, or the Mutate call was already partially evaluated and TS picked up where it left off and this was a side effect of that.

Playground Link:  https://www.typescriptlang.org/play/#code/CYUwxgNghgTiAEAzArgOzAFwJYHtXwFlkMoMQAeAFQD4AKMKCCAIyjAGsAueWqbygDTxm3VMgC2zEDACU8ALzV4lGfwDcAKCIkytXkOZzFwmWqA
Related Issues:  https://github.com/microsoft/TypeScript/issues/14829 is similar, but I don't necessarily need a NoInfer<> generic
In fact, I posted it in a comment as well: https://github.com/microsoft/TypeScript/issues/14829#issuecomment-530189002. Feel free to delete/close whichever is more appropriate.

This is intentional - consider what any possible implementation of Mutate would look like:
function Mutate<T>(callback: (a: T, b: number) => T): T {
    return callback("????", 10);
    //              ~~~~~~
}

It's impossible absent other T candidates for Mutate to provide a valid value for a, so the correct bound is unknown.


Companion EventMaster Arm/Disarm Destination

Hi everyone
I've got an issue trying to 'Arm/Disarm' Destinations via companion. Using an S3, correctly named and configured my destinations.
i am using Companion 2.1.3
A pop up message in Event master say there is a javascript error.
Is it working correctly ?
Thanks a lot.

Error suggests there's a typo at index.js:826:75 screenSestination, but I can't find this in the Repo anywhere.
Error was seen on Companion 2.1.3.

Hi Guys, I've heard this error before including the typo. My guess this has been fixed later on. I wasn't able to find/reproduce it. Please download a beta build (new 2.1 stable will be there soon also). And test that please


/dvc start crashes the server

Describe the bug
/dvc causes server crash (I am using the fabric version of the mod. This bug happens on both 3.0.1 and 3.0.2)
To Reproduce
Steps to reproduce the behavior:

Go to 'Minecraft Chat'
Type "/dvc start"
The server crashes

Expected behavior
/dvc start to work and be able to start the dvc
Screenshots
If applicable, add screenshots to help explain your problem.

(This is the only error in chat everything else is the server starting up and people joining)
Btw the mod starts correctly on 3.0.0 but the discord users can't hear simple vc.

Duplicate of #59


Question about Least Kinetic Motion Prior

Hi, I was wondering why
sf_sm_loss += args.w_sm * compute_sf_lke_loss(ret['raw_pts_ref'],
                                                    ret['raw_pts_post'],
                                                    ret['raw_pts_prev'],
                                                    H, W, focal)

is called twice at the following two lines?:
https://github.com/zhengqili/Neural-Scene-Flow-Fields/blob/d4001759a39b056c95d8bc22da34b10b4fb85afb/nsff_exp/run_nerf.py#L589
https://github.com/zhengqili/Neural-Scene-Flow-Fields/blob/86ad6ddd1ce1c758bc908ef022ce843aae323d50/nsff_exp/run_nerf.py#L593
Should compute_sf_lke_loss compute the $L_{temp}$ term?
Thank you!

Have you figured it out? I have the same question.


Working with Loopers

Is there a way to take a JObject that represents an android.os.Looper that was obtained via JNI and turn that into a ForeignLooper? I feel like this should be possible, but I don't know if it actually is and I've failed in my attempts so far.

I vaguely remember there being an API for this (or recently added) but that doesn't seem to be the case: https://developer.android.com/ndk/reference/group/looper.

@rib are you aware of any such API, besides communicating a Looper via TLS? Or are these entirely different concepts? The Java and C++ implementation seem to have different functionality and don't call into each other:
https://cs.android.com/android/platform/superproject/+/refs/heads/master:system/core/libutils/Looper.cpp
https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/Looper.java
In which case I don't think there's anything that can be done here.


compose: Convert pasted url to named link.

Fixes #18692

CZO link here
Testing plan:
I tested this manually right now for these cases.

Pasting a link
Pasting simple text
Pasting an image

Tested this on Opera, Edge browsers for now.

Select and paste a link

@timabbott I tried adding some tests to test this functionality, but I think no tests have been written before for ctrl+B, ctrl+I, so now able to get how to check this one.
I tried, but i am not able to understand how to mock the range function, like unable to think how to test that.

Hello @timabbott so I actually searched are we testing this range function anywhere or not.
I didn't find so, so yes we need to have them. We don't have even for shortcuts like Ctrl + I, Ctrl + shift + L, etc.
Regarding https://github.com/zulip/zulip/pull/17864, this checks for caret positioning, which I think is the out of the scope of this issue as this uses only range thing and caret gets automatically after the inserted value.

@vinitS101 @timabbott FYI this one is now ready for review.
I discussed about the document.execCommand onc CZO here

I merged the first two commits as the series ending with 5a61c9bb145df2db410431f7e5801712d7612ee1.
@Signior-X can you announce the feature on chat.zulip.org when we do the next deploy there?


Build in analytics / service to detect site issues, 404s

There should be a listener service that checks if certain URLs receive a high amount of 404s and then a redirect could be established.

Having said that in a different bug report I'd like to rephrase: elementary should probably use Piwik to get some stats on site usage and also identify potential issues with the site.

---
Want to back this issue? **[Post a bounty on it!](https://www.bountysource.com/issues/12969734-build-in-analytics-service-to-detect-site-issues-404s?utm_campaign=plugin&utm_content=tracker%2F10548672&utm_medium=issues&utm_source=github)** We accept bounties via [Bountysource](https://www.bountysource.com/?utm_campaign=plugin&utm_content=tracker%2F10548672&utm_medium=issues&utm_source=github).

We already have stats tracking using google analytics. However I'm not sure who has control over that. Wouldn't a piwik install be a bit overkill for just tracking 404 hit's?

We could add an event to track 404 errors with Google Analytics, as well as most other errors you can think of.

@gamerlv Piwik would only make sense as an alternative to Google Analytics of course, I didn't know MVP already used GA. Personally I think using GA is a huge privacy issue even though it is somewhat more comfortable than Piwik.
@lewisgoddard :+1:


[WIP] Add caching of transpiled circuit generation to BaseExperiment

Summary
This adds caching of transpiled circuit generation to BaseExperiment so repeated calls to run will not incur cost of circuit generation and transpilation if no options have changed.
The cache is automatically cleared if experiment options or transpile options are changed, and can be manually cleared by calling the cache_clear method.
Details and comments
Caching is implemented by a cached_method decorator which can be applied to BaseExperiment or subclass methods. This store the method return in a object instance _cache dict. This differs from built in methods like lru_cache in that it caches a single output per instance method regardless of any argument values of that method, and it stores the cached value inside the instance itself. The later point is to allow for potential saving and loading of the cache via pickling or other save/load methods.

@nkanazawa1989 Regarding your comment about setting the options without calling the option setting methods: what do you think of setting the cache key to be a hash (or simply a tuple) of the method name and all the options?

Considering all options make sense. This is another problem, but I'm not sure if all values are hashable since subclass can store whatever in options.

Closing since no longer needed


Refactor/plugin iterator

Coverage remained the same at 64.82% when pulling 4cef4720ad6e280786a4c1bbe8b0c641d45e2cbd on refactor/plugin_iterator into c5cbd36e1c761ce8e9ee75e56e7290a75bfc32a4 on next.

locally all tests pass

will push new against refactor/cli branch


Fix a broken link in docs

Fixes
Checklist

[x] I have made a material change to the repo (functionality, testing, spelling, grammar)
[x] I have read the [Contribution Guide] and my PR follows them.
[x] I updated my branch with the development branch.
[ ] I have added tests that prove my fix is effective or that my feature works
[ ] I have added necessary documentation about the functionality in the appropriate .md file
[ ] I have added in line documentation to the code I modified

Short description of what this PR does:

Improves the documentation

Hello @salah3x,Thanks again for the PR! We want to show our appreciation by sending                                              you some swag. Could you please fill out                                              this form so we can send it to you? Thanks!                                             Team SendGrid DX


Save the refid to the bag-info.txt file

Is your feature request related to a problem? Please describe.
The ArchivesSpace refid associated with a bag needs to be accessed by other microservices.
Describe the solution you'd like
Save the directory name (presumed to be a refid) as ArchivesSpace-RefID in the bag-info file.
Describe alternatives you've considered
The refid could be provided in the serialized bag data file sent to Zorya.

Bags are expected to have a ArchivesSpace-URI value in bag-info.txt, which will solve this problem.


Allow attribute selector along with tag

just trying to fit angular-split into an existing layout where modifying page structure would be difficult. Would it be possible to additionally add attribute selectors?
selector: 'split-area, [splitArea]'

I'd be more than happy to fork and submit a pull request if you are open to this change

Hi @ronnyek
I know that's late but your request will be added in 2.0.0-beta.4 version which I'm gonna publish in coming days.
@Directive({
    selector: 'as-split-area, [as-split-area]'
})


Remove discontinued tanzu builder image

Changes

:broom: Remove discontinued tanzu builder image

/kind

Fixes #

Release Note

Docs

/lgtm
/approve


SQL panel should track transactions

I often need to know exactly where we are committing inside a Django view. I've got this working with http://gist.github.com/484450
(Unfortunately, commit() and rollback() are methods of the database connection, not the cursor so we have to track them slightly differently.)

Luckily we don't support Django <1.6 anymore, so maybe, if anyone wants to tackle this...

Any further thoughts on this folks?

Oh, I'd certainly review a pull request adding this feature. It's not a thing which bothers me right now though.

Not much changed since 5 years ago ;-)

Any movement on this? Seeing transaction data in the SQL panel would be very helpful.

I'm not aware of any work happening in this area right now. Nothing has changed...


return scan count on scan

Sorry for not specifying earlier, but if they haven't RSVPd we still want to show their info (like dietary restrictions). But I would also like to extend this behaviour to other statuses as well. If they are any status other than applying, we would like to show their information. But notify the user that they have not been accepted, or have not RSPVd


Log of email issues

I’ve tried to run the code commenting the else blocks around lines 433 and 462 in utils.py. With that, I could reach the end of the code but the results look strange.
In adding to my previous comment on the unit conversion, I’d like to draw your attention to a point when applying the AK. I didn’t go to all your pieces of code in detail but as far as I quickly go through, I have understood you convert the model in molecule/cm2 before applying the AK. I’m not sure it will work for all the products. For example, for our product we retrieve vmr and then our ak correspond to o3 profiles in vmr. One can apply them directly to vmr O3 profile but I don’t think it is possible to apply them directly to molecule/cm2 columns without some conversions (we did that a long time ago at the beginning of IASI, but I don’t remember exactly what the issue was). In general, I would recommend to transform the model in the units of the o3 product, apply the ak and at the end convert to molecule/cm2. It should prevent some issues.

First, for the units, it seems that in the conversion part after line 150 of get_satellite_data.py, the case of « v/v » is not considered to be converted in molec cm-2. I was in this case and got the error message « unable to converts o3 units of v/v… »
Then, I converted in my test nc file, my O3 profile to ppb to see if it goes further. It does (see next question).
Still on units, I wonder if the conversion ppb —> molec cm-2 is correct. I would expect to have something more complicated for the conversion such as vmr*(dP/g)*(Na/mair). What do you think?
Second, independently of the units issue, I continue using ppb units. I succeed to download CAMS outputs. But the script stops without doing anything. I tracked it is quitting the code at line 432 of the utils.py script. I don’t know what’s going wrong. Below the last lines written on my screen.
--> Converting ozone from units of ppb to molec/cm2
--> Converting prior from units of ppb to molec/cm2
--> Cannot find units for level. Assuming hPa.
2022-09-30 09:10:48,027 INFO Welcome to the CDS
2022-09-30 09:10:48,028 INFO Sending request to https://ads.atmosphere.copernicus.eu/api/v2/resources/cams-global-reanalysis-eac4
2022-09-30 09:10:48,103 INFO Request is queued
2022-09-30 09:10:49,133 INFO Request is running
2022-09-30 09:10:52,944 INFO Request is completed
2022-09-30 09:10:52,945 INFO Downloading https://download-0003-ads-clone.copernicus-climate.eu/cache-compute-0003/cache/data1/adaptor.mars.internal-1664521848.1761296-22594-7-b957cfe8-358c-46db-b2fa-8ccc22e6671f.grib to /DATA/SPECAT_2/gaelle/TOAR2/toar_sample/OUT/model_download/1664521847_CAMS_model.grib (755.9K)
2022-09-30 09:10:53,333 INFO Download rate 1.9M/s
Warning: ecCodes 2.21.0 or higher is recommended. You are running version 2.18.0
Approximately 0% of profiles in this file complete.
** Quiting.

SAMPLING MODEL FOR OMI-RAL
Using the CAMS model
Retreving satellite file list
--> Found 11445 satellite files
--> Satellite records start from 2019-09-01.
Changing start date to match
--> Sampling model at satellite observations coordinates.
Sampling file: /home/users/blatter/Data/projects/ral_ozone_scheme/omi_aura/v003/omi_aura-solopt7-rat1-cclev2-saap-lip-samp1a2-samp2b2-af0-cmacc-pcbira-ecm-ec5-sfg2s-rsfw3-ng37-pol4-sc10-noxfr-ch2o-nosw-retpoly-s5xs-sckxs-ring4-smcl2-mplap-g2lk-nomr-cci-newfm2b-b2leak2-dxs2-0p006-superg/nc-rnd/2019/09/01/ESACCI-OZONE-L2P-NP-RAL_OMI_AURA-20190901005000_20190901005000-fv0214.nc
--> Converting ozone from units of DU to molec/cm2
--> Converting prior from units of DU to molec/cm2
Traceback (most recent call last):
File "sample_model.py", line 295, in
sat_data = sample_model(config_vars, satellite_info)
File "sample_model.py", line 187, in sample_model
model_data = get_CAMS_data(config_vars, sat_data)
File "/home/users/blatter/python/toar/toar_sample/CAMS_model_data.py", line 32, in init
self.download_model_data(config_vars)
File "/home/users/blatter/python/toar/toar_sample/CAMS_model_data.py", line 53, in download_model_data
c = cdsapi.Client()
File "/home/users/blatter/python_venv/toar_sample/lib/python3.8/site-packages/cdsapi/api.py", line 301, in init
raise Exception("Missing/incomplete configuration file: %s" % (dotrc))
Exception: Missing/incomplete configuration file: /home/users/blatter/.cdsapirc

In running toar_sample, the first error I met arises from reading "Time" because the variables are saved into each group.
I think, I well followed your instruction in read.me file. I defined the variable name as a group_name/var_name so that  time_var_name is given as 'HDFEOS/SWATHS/OMI Vertical Ozone Profile/Geolocation Fields/Time' in config.py.
The error message is follows as
SAMPLING MODEL FOR OMI-Aura
Using the CAMS model
Retreving satellite file list
--> Found 1 satellite file
Traceback (most recent call last):
File "sample_model.py", line 291, in
satellite_info = get_satellite_data.meta_data(config_vars)

File "/data/tempo1/Shared/jbak/toar_sample/get_satellite_data.py", line 21, in init
self.start_date, self.end_date = self.get_satellite_date_range(config_vars)

File "/data/tempo1/Shared/jbak/toar_sample/get_satellite_data.py", line 58, in get_satellite_date_range
pass_time = nc_dataset.variables[config_vars.time_var_name]

KeyError: 'HDFEOS/SWATHS/OMI Vertical Ozone Profile/Geolocation Fields/Time'

Thank you for the clarification. Now I am facing a new problem with the sample_model
As a first test I wanted to read some S5p / tropomi data (https://s5phub.copernicus.eu/dhus/#/home).
However the reading routine (get_satellite_data.py)
Asumes the file to be flat (unstructured):
class extract_data():
def init(self,config_vars,sat_file):
TODO: Change to a 'with' statement
TODO: Need to make this configurable
nc_dataset = nc.Dataset(sat_file,'r')
Try to get coord variables either as full names or shortened
lat_var = config_vars.lat_var_name
...
prior_var = config_vars.prior_var_name
time_var = config_vars.time_var_name
self.latitude = nc_dataset.variables[lat_var][:]
the data in the S5P format are structured:
lat_var= nc_dataset.groups['PRODUCT].variables['latitude'][:]
or
ak_var= nc_dataset.groups['PRODUCT'].groups['SUPPORT_DATA'].groups['DETAILED_RESULTS'].variables['averaging_kernel']
My suggeted sollution would be to allow the user GROUP/SUBGROUP/Variable as input in config.py and split the input according to
input_array=input_variable.split('/')
if len(input_array)==1:
_var= nc_datatset.variable[input_variable][:]
else:
readgroud=nc_dataset
for sub_group in range(len(input_array))-1:
readrgoup=readgroup.goups[input_array[sub_group]]
_var= readgroup.variable[input_array[-1]][:]
As an alternative we might use h5py.file instead of nc.Dataset
here we can directly use nc_datatset =h5py.file(sat_file)
nc_dataset[input_variable][:]
as long as the input is given as 'group/variable' it can read it
I will test the later version locally


Place 'r' prefix before 'f' for raw format strings

Summary

Currently, UP032 applied to raw strings results in format strings with the prefix 'fr'. This gets changed to 'rf' by Ruff format (or Black). In order to avoid that, this PR uses the prefix 'rf' to begin with.
Test Plan

Updated the expectation on an existing test.

Thanks, that's a great idea. I'll review and merge this later today.

Thanks for getting involved! Great PR.


fix: error message for Vault store validation of Auth.Jwt.KubernetesServiceAccountToken

The error message for an invalid SecretRef was used before mistakenly.

/approve

/merge


🐛 BUG: Default 'npm create cloudflare' workflow for next.js leads to nodejs_compat error page

Which Cloudflare product(s) does this pertain to?
C3
What version of Wrangler are you using?
3.1.1
What operating system are you using?
Mac
Describe the Bug
If I create a next.js app using C3 and deploy it on pages, I get an error about not having the nodejs_compat flag set when I visit the site.  It looks like I've deployed it successfully and it's unclear how to fix the issue.  It's a bad first experience for someone trying to deploy.
The solution is outlined in https://developers.cloudflare.com/workers/platform/nodejs-compatibility/, but even then it's unclear what I should do.  There is no wrangler.toml, so the easiest method to fix it is by navigating to the dashboard.  We should be able to detect if the flag is not set when working through the C3 workflow and guide them to setting the flag, or just set it for them since we know it's a new project (they did a create) and it won't work without it.

We need to fix up the docs to use @latest - see https://developers.cloudflare.com/pages/get-started/c3/
cc @admah

Latest did fix the issue.  Thanks @petebacondarwin .

Cool. Closing this for now.


Callable function doesn't work with firebase serve

I've followed the README for callable functions (https://github.com/firebase/quickstart-js/blob/master/functions/README.md).
I'd expect the example to work locally (as per https://firebase.google.com/docs/functions/local-emulator), so I tried to run the example with firebase serve.
After I sign in and click on "Add the two numbers", I get the following CORS error:

Why is the code trying to hit a cloud endpoint when running locally, shouldn't it be hitting the emulated functions running on localhost?

I believe this has been fixed in the latest version of the Firebase CLI: https://github.com/firebase/firebase-tools/pull/1335
I'm going to close this out, but if anyone is still experiencing this, please comment and I'll reopen.

I am using latest CLI of firebase but

Access to fetch at 'https://us-central1-quickstart-js-c36d9.cloudfunctions.net/addNumbers' from origin 'https://quickstart-js-c36d9.firebaseapp.com' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.


[Feature_Request] Support optional flag with extendedWaitUntil & visible/notVisible with timeouts

Requirement : Right now there is not action to force wait the app on a fixed time of duration , if we can support "optional" flag with
extendedWaitUntil:
notVisible/visible:
optional:
timeout:
we can achieve the force wait in larger performance related test cases (e.g keeping app for longer duration of time and cross check for memory leaks )

@axelniklasson hey , had to close the previous issue as I used wrong account to log it, and to your question , Yes it is similar to sleep command or a forced delay

Got it @manjususan11, thanks for the context. As we outline in our docs, we highly discourage the pattern of introducing artifical waits in your application. Could you elaborate a bit more on your use case and why you need to optional flag?

@axelniklasson Sure, my requirement is to run my navigation app for a larger duration with some condition in backend which helps in identifying memory leaks if any , unfortunately while it is routing I won't be getting any new UI element or disappear any existing element so can't use any assert visible or notVisible much here , but if I have a sleep feature(OR optional assertVisible/notVisible with a timeout ) I can ask the test to wait for some  minutes and then stop test successfully but I need some screenshots in between(may be every 20 mins )
I hope it is clear :)

Got it, I see your use case. We are quite hesitant to introduce artifical waits that are not depending on UI changes as it will most likely be overused and hide UX issues, so I would recommend trying another approach to do what you want. Maybe you could use maestro to interact with your app all the way to the video recording and then hand off to another process to check for memory leaks?

I also would like an extended wait for the app.
Sometimes you really do want an escape hatch to wait an arbitrary time for something to update, and sometimes redesigning features isn't always an option.
Adding a warning to the command usage in the cli output could be useful.
All major testing frameworks allow artificial waits, and it's something that when used with caution can be very useful.

Not meaning to deviate from this issue, but I had a similar request in the past and I have explained my use case here: https://github.com/mobile-dev-inc/maestro/issues/684 @axelniklasson

@manjususan11 in case you haven't figured it out yet, this is now possible:
- extendedWaitUntil:
      visible:
        text: "Test"
        optional: true
      timeout: 10000


Add SLP support

Should verify that the address conversion is actually right.

Pull Request Test Coverage Report for Build 15

27 of 29 (93.1%)  changed or added relevant lines in 1 file are covered.
No unchanged relevant lines lost coverage.
Overall coverage decreased (-0.4%) to 92.694%

Changes Missing Coverage
Covered Lines
Changed/Added Lines
%

cashaddress/convert.py
27
29
93.1%

Totals

Change from base Build 14:
-0.4%

Covered Lines:
203

Relevant Lines:
219

💛  - Coveralls

Thanks for adding tests with this. With adding SLP, my thought is that it'd be nice to have a separate functions here. Maybe like, validate_slp_address or validate_pkh_address, or something like that.
Otherwise might get a simpletoken address and try to process it while not being able to support it, even though the address itself is technically valid.


Missing DomSanitizer arguments

Version
7.0.0-rc.3
Environment
Windows
Reproduction link
https://stackblitz.com/edit/ng-zorro-antd-start-uax5bc
Steps to reproduce
in
https://github.com/NG-ZORRO/ng-zorro-antd/blob/6554cf51ccbce08c755b0a3b8a9e968771c3113d/components/icon/nz-icon.service.ts#L143
you have to pass DomSanitizer
What is expected?
passing DomSanitizer to super icon service
What is actually happening?
arguments missed
Other?
check https://github.com/ant-design/ant-design-icons/blob/39d709f11e47f8a9c32ba2449f8f7df09f77f959/packages/icons-angular/lib/component/icon.service.ts#L64

@KhaledSMQ
Currently, ng-zorro-antd is depending on @ant-design/icons-angular 2.0.0-beta.1. And in that version, the constructor on IconService is:
constructor(
    protected _rendererFactory: RendererFactory2,
    @Optional() protected _handler: HttpBackend,
    @Optional() @Inject(DOCUMENT) protected _document: any
  ) {
    this._renderer = this._rendererFactory.createRenderer(null, null);
    if (this._handler) {
      this._http = new HttpClient(this._handler);
    }
  }

And I've opened a pr #2641 to update this dependency.
Thanks for you care.


Existing Guid based ID columns do not work...

Describe the bug
Create a class with a Guid ID that is pre-loaded... it can not be bulk inserted...
To Reproduce
Steps to reproduce the behavior:

Clone BulkInsert.With_Complex_Key
Create class ProductWithExistingGuidKey with an ID field (initialized in Constructor to new Guid)

Expected behavior
Items are bulk inserted.
Screenshots

Desktop (please complete the following information):

OS: Windo2w 11.
N/A
Fresh clone of repository a few hours ago.

Additional context
Add any other context about the problem here.

davidcorbin-atmosera,
I am not sure if this is a bug or just a lack of a good error message. You specified an ID column and by default EF will identify it as a primary key column with ValuedGenerated=OnAdd. The extension library is expecting the database to generate the id column. In order to fix this error you would have to specify the "[DatabaseGenerated(DatabaseGeneratedOption.None)]" attribute on the Id column as shown below. I will do some more research on this issue in order to validate my initial findings and I will report what I discover.
public class ProductWithExistingKey {     [DatabaseGenerated(DatabaseGeneratedOption.None)]     public Guid Id { get; set; }     public string Name { get; set; }     public decimal Price { get; set; }     public ProductWithExistingKey()     {         Id = Guid.NewGuid();     } }

First, thanks for getting back to me so fast....
My expectation (which could be off-base)... is that code that works with DbSet<Entity>.Add(entity) followed by a Context.SaveChanges().  would work without changes when moving to Bulk operations on the same set of entities (into the same Db, etc...)


Bump aptible-resource

This new version adds persistent HTTP connections.

cc @fancyremarker

Codecov Report

Merging #248 into master will increase coverage by 0.08%.
The diff coverage is n/a.

@@            Coverage Diff             @@
##           master     #248      +/-   ##
==========================================
+ Coverage    96.8%   96.89%   +0.08%
==========================================
  Files          81       81
  Lines        3416     3416
==========================================
+ Hits         3307     3310       +3
+ Misses        109      106       -3

Impacted Files
Coverage Δ

lib/aptible/cli/helpers/tunnel.rb
96.61% <0%> (+5.08%)
:arrow_up:

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 4c6ba2a...848cd8b. Read the comment docs.


Run rkt fetch as a user in the rkt group.
What did you expect to see?
The image being fetched successfully.
What did you see instead?
An error:
$ groups | grep --silent rkt
$ echo $?
0
$ rkt fetch coreos.com/etcd:v2.3.1
image: searching for app image coreos.com/etcd
image: remote fetching from URL "https://github.com/coreos/etcd/releases/download/v2.3.1/etcd-v2.3.1-linux-amd64.aci"
image: keys already exist for prefix "coreos.com/etcd", not fetching again
image: downloading signature from https://github.com/coreos/etcd/releases/download/v2.3.1/etcd-v2.3.1-linux-amd64.aci.asc
Downloading signature: [=======================================] 287 B/287 B
Downloading ACI: [=============================================] 8.11 MB/8.11 MB
image: signature verified:
  CoreOS Application Signing Key<EMAIL_ADDRESS>fetch: open /var/lib/rkt/cas/treestorelocks/deps-sha512-b2c2b0239bf61a6d35772b094925db080038bd51cae5b0fe7ff701256c3cd9fc: permission denied

After https://github.com/coreos/rkt/pull/2398, we render images on rkt fetch.
This doesn't work becase we set the permissions of /var/lib/rkt/cas/{tree,treestorelocks} to 2700 which means the rkt group can't access them.
Even with 2770, it fails with
fetch: extracttar error: exit status 1, output: chroot capability not available.

Because we create a chroot to extract the ACI.

So we could just skip the rendering during the fetch if rkt is not running as root?

So we could just skip the rendering during the fetch if rkt is not running as root?

That was my first idea...


Door lock failed and broke the connection because of null ack

The smart door lock failed to handle switch to lock/unlock because js call returned a null ack.
log:

eufy-security.0 | 2021-07-06 08:43:07.204 | error | (15193) Cannot read property 'ack' of null
eufy-security.0 | 2021-07-06 08:43:07.204 | error | at fulfilled (/opt/iobroker/node_modules/iobroker.eufy-security/build/lib/eufy-security/eufy-security.js:5:58)
eufy-security.0 | 2021-07-06 08:43:07.204 | error | at Generator.next (<anonymous>)
eufy-security.0 | 2021-07-06 08:43:07.204 | error | at EufySecurity.<anonymous> (/opt/iobroker/node_modules/iobroker.eufy-security/build/lib/eufy-security/eufy-security.js:219:44)
eufy-security.0 | 2021-07-06 08:43:07.204 | error | (15193) TypeError: Cannot read property 'ack' of null
eufy-security.0 | 2021-07-06 08:43:07.204 | error | (15193) unhandled promise rejection: Cannot read property 'ack' of null
eufy-security.0 | 2021-07-06 08:43:07.203 | error | (15193) Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch bloc

host.iobroker | 2021-07-06 08:43:09.403 | error | instance system.adapter.eufy-security.0 terminated with code 6 (UNCAUGHT_EXCEPTION)

eufy-security.0 | 2021-07-06 08:43:09.385 | error | (15193) DB closed
eufy-security.0 | 2021-07-06 08:43:09.385 | error | at TCP.<anonymous> (net.js:675:12)
eufy-security.0 | 2021-07-06 08:43:09.385 | error | at Socket.emit (events.js:314:20)
eufy-security.0 | 2021-07-06 08:43:09.385 | error | at Object.onceWrapper (events.js:421:26)
eufy-security.0 | 2021-07-06 08:43:09.385 | error | at Socket.<anonymous> (/opt/iobroker/node_modules/ioredis/built/redis/event_handler.js:150:20)
eufy-security.0 | 2021-07-06 08:43:09.385 | error | at close (/opt/iobroker/node_modules/ioredis/built/redis/event_handler.js:183:25)
eufy-security.0 | 2021-07-06 08:43:09.385 | error | (15193) Error: DB closed
eufy-security.0 | 2021-07-06 08:43:09.385 | error | (15193) unhandled promise rejection: DB closed
eufy-security.0 | 2021-07-06 08:43:09.385 | error | (15193) Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch().
eufy-security.0 | 2021-07-06 08:43:09.385 | error | (15193) DB closed
eufy-security.0 | 2021-07-06 08:43:09.384 | error | at TCP.<anonymous> (net.js:675:12)
eufy-security.0 | 2021-07-06 08:43:09.384 | error | at Socket.emit (events.js:314:20)
eufy-security.0 | 2021-07-06 08:43:09.384 | error | at Object.onceWrapper (events.js:421:26)
eufy-security.0 | 2021-07-06 08:43:09.384 | error | at Socket.<anonymous> (/opt/iobroker/node_modules/ioredis/built/redis/event_handler.js:150:20)
eufy-security.0 | 2021-07-06 08:43:09.384 | error | at close (/opt/iobroker/node_modules/ioredis/built/redis/event_handler.js:183:25)
eufy-security.0 | 2021-07-06 08:43:09.384 | error | (15193) Error: DB closed
eufy-security.0 | 2021-07-06 08:43:09.384 | error | (15193) unhandled promise rejection: DB closed
eufy-security.0 | 2021-07-06 08:43:09.384 | error | (15193) Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch().
eufy-security.0 | 2021-07-06 08:43:09.383 | error | (15193) DB closed
eufy-security.0 | 2021-07-06 08:43:09.383 | error | at TCP.<anonymous> (net.js:675:12)
eufy-security.0 | 2021-07-06 08:43:09.383 | error | at Socket.emit (events.js:314:20)
eufy-security.0 | 2021-07-06 08:43:09.383 | error | at Object.onceWrapper (events.js:421:26)
eufy-security.0 | 2021-07-06 08:43:09.383 | error | at Socket.<anonymous> (/opt/iobroker/node_modules/ioredis/built/redis/event_handler.js:150:20)
eufy-security.0 | 2021-07-06 08:43:09.383 | error | at close (/opt/iobroker/node_modules/ioredis/built/redis/event_handler.js:183:25)
eufy-security.0 | 2021-07-06 08:43:09.383 | error | (15193) Error: DB closed
eufy-security.0 | 2021-07-06 08:43:09.382 | error | (15193) unhandled promise rejection: DB closed
eufy-security.0 | 2021-07-06 08:43:09.382 | error | (15193) Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch bloc

The issue is gone after update to 0.55


mscoco pretrained weights uncorrect！

I downloaded the mscoco pretrained weights (d0, d1 and d2), and test  with the script inference.py. The output scores are all very small, around 0.01.  I found that the model can output different scores with the same input and model weights. I guess there is something wrong in the pretrained weights, and the script inference.py can not load all model weights correctly. Can you check this please?

did you set weighted Bifpn=True in inference.py?

I tried D0 and it works:

with this in inference
def main():
    os.environ['CUDA_VISIBLE_DEVICES'] = '0'

    phi = 0
    weighted_bifpn = True
    model_path = 'test/efficientdet-d0.h5'
    image_sizes = (512, 640, 768, 896, 1024, 1280, 1408)
    image_size = image_sizes[phi]
    # coco classes
    classes = {value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values()}
    num_classes = 90
    score_threshold = 0.3

@SiBensberg Could you help me check out my code? I want to use efficientdet-d0 to predict on single image but get nothing, and the scores of the mode predict are all -1. Here is my code:
from model import efficientdet
import cv2
import os
import numpy as np
import time
import argparse
from utils.anchors import anchors_for_shape

num_classes = 90
score_threshold = 0.1
colors = [np.random.randint(0, 256, 3).tolist() for i in range(num_classes)]

def infer(model, img, anchors):
    src_image = img.copy()
    h, w = src_image.shape[:2]
    image, scale, offset_h, offset_w = preprocess(img, 512)

    start = time.time()
    boxes, scores, labels = model.predict_on_batch(
        [np.expand_dims(image, axis=0), np.expand_dims(anchors, axis=0)]
    )
    end = time.time()
    print ('infer time == ', end-start)

    boxes[0, :, [0, 2]] = boxes[0, :, [0, 2]] - offset_w
    boxes[0, :, [1, 3]] = boxes[0, :, [1, 3]] - offset_h
    boxes /= scale
    boxes[0, :, 0] = np.clip(boxes[0, :, 0], 0, w - 1)
    boxes[0, :, 1] = np.clip(boxes[0, :, 1], 0, h - 1)
    boxes[0, :, 2] = np.clip(boxes[0, :, 2], 0, w - 1)
    boxes[0, :, 3] = np.clip(boxes[0, :, 3], 0, h - 1)

    print (scores)

    # select indices which have a score above the threshold
    indices = np.where(scores[0, :] > score_threshold)[0]

    # select those detections
    boxes = boxes[0, indices]
    scores = scores[0, indices]
    labels = labels[0, indices]

    for box, score, label in zip(boxes, scores, labels):
        xmin = int(round(box[0]))
        ymin = int(round(box[1]))
        xmax = int(round(box[2]))
        ymax = int(round(box[3]))
        score = '{:.4f}'.format(score)
        class_id = int(label)
        color = colors[class_id]
        # class_name = classes[class_id]
        class_name = class_id
        label = '-'.join([class_name, score])
        ret, baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
        cv2.rectangle(src_image, (xmin, ymin), (xmax, ymax), color, 1)
        cv2.rectangle(src_image, (xmin, ymax - ret[1] - baseline), (xmin + ret[0], ymax), color, -1)
        cv2.putText(src_image, label, (xmin, ymax - baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1)

    return src_image

def preprocess(image, image_size):
    image_height, image_width = image.shape[:2]
    if image_height > image_width:
        scale = image_size / image_height
        resized_height = image_size
        resized_width = int(image_width * scale)
    else:
        scale = image_size / image_width
        resized_height = int(image_height * scale)
        resized_width = image_size
    image = cv2.resize(image, (resized_width, resized_height))
    new_image = np.ones((image_size, image_size, 3), dtype=np.float32) * 128.
    offset_h = (image_size - resized_height) // 2
    offset_w = (image_size - resized_width) // 2
    new_image[offset_h:offset_h + resized_height, offset_w:offset_w + resized_width] = image.astype(np.float32)
    new_image /= 255.
    mean = [0.485, 0.456, 0.406]
    std = [0.229, 0.224, 0.225]
    new_image[..., 0] -= mean[0]
    new_image[..., 1] -= mean[1]
    new_image[..., 2] -= mean[2]
    new_image[..., 0] /= std[0]
    new_image[..., 1] /= std[1]
    new_image[..., 2] /= std[2]
    return new_image, scale, offset_h, offset_w

if __name__ == '__main__':

    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
    os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'

    parser = argparse.ArgumentParser()
    parser.add_argument('--img', type=str, default='/media/hsw/E/datasets/crowdpose/crowdpose_images')
    parser.add_argument('--model', type=str, default='weights/efficientdet-d0.h5')
    args = parser.parse_args()

    model, prediction_model = efficientdet(phi=0, num_classes=num_classes, weighted_bifpn=True, score_threshold=score_threshold)

    prediction_model.load_weights(args.model, by_name=True)
    print ("Successfully load pretrained model")

    anchors = anchors_for_shape((512,512))

    for img_name in os.listdir(args.img):
        img = cv2.imread(os.path.join(args.img, img_name))
        img = infer(prediction_model, img, anchors)
        cv2.imshow('result', img)
        key = cv2.waitKey(0)
        if key == ord('q'):
            break

Is there some wrong? I used coco pretrained model.
Env:

tensorflow 1.15.1
cuda 10.1
python 3.6

Thank you very much.

I tried D0 and it works:

with this in inference
def main():
    os.environ['CUDA_VISIBLE_DEVICES'] = '0'

    phi = 0
    weighted_bifpn = True
    model_path = 'test/efficientdet-d0.h5'
    image_sizes = (512, 640, 768, 896, 1024, 1280, 1408)
    image_size = image_sizes[phi]
    # coco classes
    classes = {value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values()}
    num_classes = 90
    score_threshold = 0.3

what is your ternsorflow and keras version?

@murdockhou I have the same problem with yours.

@luckycallor Have you solved this problem? I do not want use the inference.py provided by author, because I want to predict on mine image or video. But get nothing and the scores predicted are all -1. The complete code is above, alos tensorflow version(keras is embeded within tensorflow).

@murdockhou I used the inference.py provided by author, but have the same problem with yours. I have not solved it yet.

@SiBensberg Yes, I setted the weighted Bifpn=True, but get nothing, and the scores of the mode predict are all -1. Can you tell me more details about you code and run envs. Here is my code:
`import cv2
import json
import numpy as np
import os
import time
import glob
from model import efficientdet
from utils import preprocess_image, postprocess_boxes
from utils.draw_boxes import draw_boxes
def main():
# os.environ['CUDA_VISIBLE_DEVICES'] = '0'
phi = 0
weighted_bifpn = True
model_path = 'pretrained/efficientdet-d0.h5'
image_path = 'test_image/tDQGinHoJ0_small.jpg'
image_sizes = (512, 640, 768, 896, 1024, 1280, 1408)
image_size = image_sizes[phi]
# coco classes
classes = {value['id'] - 1: value['name'] for value in json.load(open('coco_90.json', 'r')).values()}
num_classes = 90
score_threshold = 0.3
colors = [np.random.randint(0, 256, 3).tolist() for _ in range(num_classes)]
_, model = efficientdet(phi=phi,
                        weighted_bifpn=weighted_bifpn,
                        num_classes=num_classes,
                        score_threshold=score_threshold)
model.load_weights(model_path, by_name=True)

# for image_path in glob.glob('datasets/VOC2007/JPEGImages/*.jpg'):
image = cv2.imread(image_path)
src_image = image.copy()
# BGR -> RGB
image = image[:, :, ::-1]
h, w = image.shape[:2]

image, scale = preprocess_image(image, image_size=image_size)
# run network
start = time.time()
boxes, scores, labels = model.predict_on_batch([np.expand_dims(image, axis=0)])
boxes, scores, labels = np.squeeze(boxes), np.squeeze(scores), np.squeeze(labels)
print(time.time() - start)
boxes = postprocess_boxes(boxes=boxes, scale=scale, height=h, width=w)

# select indices which have a score above the threshold
indices = np.where(scores[:] > score_threshold)[0]

# select those detections
boxes = boxes[indices]
labels = labels[indices]

draw_boxes(src_image, boxes, scores, labels, colors, classes)

cv2.imwrite('test_image/res.jpg', src_image)

    # cv2.namedWindow('image', cv2.WINDOW_NORMAL)
    # cv2.imshow('image', src_image)
    # cv2.waitKey(0)

if name == 'main':
main()`
The env is:
python3.6.4
tensorflow 1.14.0
keras 2.2.4

I actually changed nothing else in the code. I made a fresh conda environment with

tensorflow-gpu 1.15
cuda 10.0.130
cudnn 7.6.5

However I found 2 similiar issues to yours, you could try the solutions they provided. I hope that helps.
#126
#108


32 bit deb package requires 64 bit libraries

This is on a i386 Debian jessie system:
# dpkg -i Brackets.Release.0.45.32-bit.deb
(Reading database ... 350326 files and directories currently installed.)
Preparing to unpack Brackets.Release.0.45.32-bit.deb ...
Unpacking brackets (0.45.0-15087) over (0.45.0-15087) ...
Setting up brackets (0.45.0-15087) ...
libnspr4.so.0d not found in /lib/x86_64-linux-gnu/libnspr4.so or /usr/lib/x86_64-linux-gnu/libnspr4.so.
dpkg: error processing package brackets (--install):
 subprocess installed post-installation script returned error exit status 1
Processing triggers for menu (2.1.47) ...
Processing triggers for hicolor-icon-theme (0.13-1) ...
Errors were encountered while processing:
 brackets

After I install libnss3-1d:amd64:
# dpkg -i Brackets.Release.0.45.32-bit.deb
(Reading database ... 350336 files and directories currently installed.)
Preparing to unpack Brackets.Release.0.45.32-bit.deb ...
Unpacking brackets (0.45.0-15087) over (0.45.0-15087) ...
Setting up brackets (0.45.0-15087) ...
libssl3.so.1d not found in /lib/x86_64-linux-gnu/libssl3.so or /usr/lib/x86_64-linux-gnu/libssl3.so.
dpkg: error processing package brackets (--install):
 subprocess installed post-installation script returned error exit status 1
Processing triggers for menu (2.1.47) ...
Processing triggers for hicolor-icon-theme (0.13-1) ...
Errors were encountered while processing:
 brackets

After that I also installed libnspr4-0d:amd64 so brackets package installed OK, but it still couldn't start:
$ brackets
/usr/bin/brackets: error while loading shared libraries: libudev.so.0: wrong ELF class: ELFCLASS64
$ ldd /opt/brackets/Brackets | grep found
        libudev.so.0 => not found

Unfortunately there is no libudev0 in jessie but libudev1. Workaround is getting an older copy from Debian Snapshot archive.
In conclusion:

32 bit deb package installation fails when 64 bit libraries are missing
deb package doesn't declare its real dependencies which causes it to be DOA
IMO deb package should bundle libudev0 or should depend on a newer version since this library version is missing on Ubuntu 12.10+ and Debian jessie+.

U can limply create a symbolic link with the old name referencing the new library like this "sudo ln -s /lib/x86_64-linux-gnu/libudev.so.1 /lib/x86_64-linux-gnu/libudev.so.0" - this is the location for linux mint. On other systems u probably have to adjust the path...


Called Amplify.Auth.signOut() after webUI signIn does not clear session

Describe the bug
When I am using Amplify.Auth.signOut() method for signout locally, it doesn't work. It gives "Successfully signed out" but next time when i called Amplify.Auth.signInWithWebUI(for: .google....... application is not asked for sign in details of google account and it automatically gets from preivously signedin user and it goes to successfully sign in.
To Reproduce
Steps to reproduce the behavior:

First I am sign in with this method. So application asked me google id and password (Frist time only) then it will successfully sign in.

        Amplify.Auth.signInWithWebUI(for: .google, presentationAnchor: window!) { result in
               switch result {
               case .success:
                   print("Google Sign in succeeded")
               case .failure(let error):
                   print("Sign in failed \(error)")
               }
           }

Now i am calling a sign out locally. Which is also called successfully with signed out block.

Amplify.Auth.signOut() { result in
            switch result {
            case .success:
                print("Successfully signed out")
            case .failure(let error):
                print("Sign out failed with error \(error)")
            }
        }

Now I again sign in with the step #1. it will not asking me to enter google id and password for sign in. Just like the video i attached.

Expected behavior
After signout it should asked me a signin details screen again.
Screenshots

Environment(please complete the following information):

Amplify Framework Version: 1.5.0
Dependency Manager: Cocoapods
Swift Version : 5.0

Device Information (please complete the following information):

Device: iPhone 8 Plus simulator, iPhone 7plus real device
iOS Version: 14
Specific to simulators:

Duplicate of #958

Resolving this as a dupe, but referencing this issue from #958 to make sure we can see the useful context & code snippets.

One thing I would like to know is that why does this Amplify.Auth.signOut() function opens the web UI with
"..." wants to use "..." to sign in. My expectation is that this webUI is only needed when the user is trying to sign in, but not at the time that the user wants to sign out.
I am currently facing this issue, and want to know if there is an issue already about that, otherwise wants to know if someone knows how to not showing that web UI at the time of sign out.

@Eric1015 @brandonmaul
You can prevent the web view from being displayed by passing in the option prefersPrivateSession().
Documentation around this can be found here.
If you have any further questions about this, please open a separate issue. Thanks!


bookstack: 24.02 -> 24.02.2

Automatic update generated by nixpkgs-update tools. This update was made based on information from https://github.com/bookstackapp/bookstack/releases.
meta.description for bookstack is: A platform to create documentation/wiki content built with PHP & Laravel
meta.homepage for bookstack is: https://www.bookstackapp.com/
Updates performed

Version update

To inspect upstream changes

Release on GitHub

Compare changes on GitHub

Impact
Checks done

built on NixOS
The tests defined in passthru.tests, if any, passed
found 24.02.2 with grep in /nix/store/plzw0678kyxchnkv423dy4f3nz6d4kmv-bookstack

Rebuild report (if merged into master) (click to expand)

1 total rebuild path(s)

1 package rebuild(s)

First fifty rebuilds by attrpath
bookstack

Instructions to test this update (click to expand)

Either download from Cachix:
nix-store -r /nix/store/plzw0678kyxchnkv423dy4f3nz6d4kmv-bookstack \
  --option binary-caches 'https://cache.nixos.org/ https://nix-community.cachix.org/' \
  --option trusted-public-keys '
  nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs=
  cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=
  '

(The Cachix cache is only trusted for this store-path realization.)
For the Cachix download to work, your user must be in the trusted-users list or you can use sudo since root is effectively trusted.
Or, build yourself:
nix-build -A bookstack https://github.com/r-ryantm/nixpkgs/archive/33b96ccf22f9d85ca284fd242d0256ea6de3b8da.tar.gz

Or:
nix build github:r-ryantm/nixpkgs/33b96ccf22f9d85ca284fd242d0256ea6de3b8da#bookstack

After you've downloaded or built it, look at the files and if there are any, run the binaries:
ls -la /nix/store/plzw0678kyxchnkv423dy4f3nz6d4kmv-bookstack
ls -la /nix/store/plzw0678kyxchnkv423dy4f3nz6d4kmv-bookstack/bin

Pre-merge build results
We have automatically built all packages that will get rebuilt due to
this change.
This gives evidence on whether the upgrade will break dependent packages.
Note sometimes packages show up as failed to build independent of the
change, simply because they are already broken on the target branch.
Result of nixpkgs-review --extra-nixpkgs-config '{ allowInsecurePredicate = x: true; }' run on x86_64-linux 1

1 package built:

bookstack

Maintainer pings
cc @ymarkus for testing.

see #294957


[core-amqp][service-bus] Prunes core-amqp public API and move ServiceBusError.reason to ServiceBusError.code

This change updates the ServiceBusError.code field to match what was the ServiceBusError.reason field.
This allows us to remove the MessagingErrorCodes from the public interface, which we don't see as providing value above and beyond what the ServiceBusCodes provides.

/azp run js - servicebus - tests

/azp run js - servicebus - tests

Please update #12117 with a summary of the final approach we have taken here.
Closes #12117

/azp run js - servicebus - tests


Discussion + Planning: How to unittest an agent?

There are a lot of bugs we have run into with regard to different behavior in different implementation/generations of code, and these issues are pretty hard to track down. I would like to move toward having a way to unittest agents.
The way we 'test' agents right now involves running the agents with altrain (which spins up another server that hosts a tutor in the browser) and then in the short term we look a the general behavior of the agent transactions as they are printed in the terminal, and maybe we additionally print out some of what is happening internally with the agent. And in the long term we look at the learning curves, which usually involves first doing some pre-processing/KC labeling and uploading to datashop.
It would be nice to have unittests at the level of "the agent is at this point in training with these skills, and we'll give it these interactions, and we expect this to happen".
Some impediments to doing this:

Modularity: At the moment, the most straightforward way to run AL is via altrain, but this is more of an integration test, it requires spinning up a new process that utilizes a completely different library (that we have kept seperate from AL_Core for good reason).
Performance: right now (ballpark estimate) AL_Core is 50% of training time and AL_Train is another 50% and together all that back and forth takes several minutes per agent. It would be nice if our tests ran on the order of seconds to make iterating on the code faster.
No robust way to "Construct" a skill(s): Skills at least in the ModularAgent right now are kind of a hodgepodge of learning mechanisms that are linked together. They are also learned, not defined. It would be nice if there was some language for writing and representing Skills.
Randomness: Some of the process of learning skills is random so this may need to be controlled some way.

I've been flirting with the idea of having a sort of virtual tutor that is just a knowledge-base that gets updated in python, executes the tutor logic, and calls request/train. This would at least address 1) and maybe also 2).

Related to #57, which has always been my big concern with testing whole agents. Would be great to have someone go through and try to catalog all the things that use some kind of random choice and see if we can set some master seed.

@cmaclell Don't you have something like the virtual tutor idea in the works? One concern with some of that would be over fitting to a testcase. Might be nice to have some kind of regular batch process (probably not using current CI tools but maybe) that re-runs some of our canonical experiments and reports fit to human data just so we can see cases when we totally break something there.

Made a new issue for CI #74

I do, it is located here: https://gitlab.cci.drexel.edu/teachable-ai-lab/tutorenvs https://gitlab.cci.drexel.edu/teachable-ai-lab/tutorenvs
You might get overfitting, but it does currently randomly generate problems / orders.
Best wishes,
Chris

On Dec 7, 2020, at 3:04 PM, Erik Harpstead<EMAIL_ADDRESS>wrote:
@cmaclell https://github.com/cmaclell Don't you have something like the virtual tutor idea in the works? One concern with some of that would be over fitting to a testcase. Might be nice to have some kind of regular batch process (probably not using current CI tools but maybe) that re-runs some of our canonical experiments and reports fit to human data just so we can see cases when we totally break something there.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub https://github.com/apprenticelearner/AL_Core/issues/72#issuecomment-740149273, or unsubscribe https://github.com/notifications/unsubscribe-auth/AAEHALEMTQNBP5VKMEO6WQLSTUYOTANCNFSM4UQZVDJQ.

@DannyWeitekamp how would you feel about making a separate repo dedicated to testing?

whoops, clicked the wrong button...

So beyond some of the issues with why this will be hard to implement what would be some good tests? Some I can think of:

Basic API sanity checks

Train A, A, A, A, A: Request A -> A
Train A, A, A, A, A: Request B -> hint request
Train A, B, A, B, A, B: Request A -> A, Request B ->B
Train +A, -A, +A, -A: Request A -> hint request

Rerun the fractions example

basically codify our current de facto testing paradigm
take a collection of items (probably mixed problem types?)
do an incremental prediction task type thing where you train 1 problem, then iterate through them with requests for "grading", test for error rate monotonically decreasing and hitting 0 by at least 3x? runs through the training data. If we control the training set we can probably assume this sufficiently.
could also have block v interleave variant or another main effect type tests. Not sure we want to assume this effect for all agent types.

Benchmark drift

We can run our current agents and come up with some kind of benchmark metric (could be something like mastery level at each opp for a population of 10? agents) we then peg that benchmark and track that agents remain within some tolerance level.
Could this is as a good way to make sure we didn't break something.

I guess part of this what high level assumptions do we want to make about all agents? Some that seem reasonable, though might not apply to all agent types or goals;

Reaching mastery (could be hitting 0 error rate or some kind of 95% threshold) after some amount of training.
Monotonic decrease in error rate, assuming training without intentional interference effects.
Demonstrating blocked versus interleaved interference effect. (could see this not being for all agent types)

I'm not entirely clear on what you both mean by overfitting, the agent overfits or there is some fitting in the environment?
Thanks @cmaclell these seem like a step in the right direction I'll take a closer look.
@eharpste these are all things that would be good to incorporate. For the non-deep learning based agents (or at least ModularAgent) expanding on 1, it would be nice to test things that are inside the agent (more of the unit test variety) beyond behavior like:

If the agent runs the planner the true explanation is in the set of found explanations
A new skill is created if the agent falls back on the planner
The where conditions never over-generalize (i.e. test for this)

I meant overfitting in a general software engineering sense not an ML sense. Basically, we don't want to stay myopically focused on the few test cases we define in cases where things might change as we explore new directions. For example, there are some known cases where the blocked vs interleaved effect should invert.

Ahh I see. The unit tests I'm suggesting would be written on an agent by agent basis. For a given implementation there are a set of intended behaviors that should be directly enforced via unit tests. If the intended behaviors change then the unit tests should change, but if they don't change then they should still pass regardless of implementation changes or additions.


[STORM-1990] Make some constant unvisible

STORM-1990 Make some constant unvisible
Some constant used as default config , make them private and unvisible .

@darionyaphet - are these changes necessary?


[incubator/kubernetes-vault] adding new incubator project

Kubernetes-Vault to incubator repo.
Reviewers:
I was finishing creating this chart when it was pointed out that there already is a chart PR for this project here: https://github.com/kubernetes/charts/pull/1396. Since I already have moved ahead with this chart and nearing completion I decided to submit it and leave the community and the author @bbriggs how to reconcile these two, the more info and viewpoints the better is the philosophy here.

I'd be happy to help reconcile this with you! Many contributors and views makes for stronger systems.

Is it ok to close #1396 then?

Please apply best practices, especially regarding standard labels:
https://github.com/kubernetes/helm/blob/master/docs/chart_best_practices/labels.md
See chart examples for reference:
https://github.com/kubernetes/helm/tree/master/docs/examples/nginx
Regarding RBAC, please follow this style:
https://github.com/kubernetes/charts/pull/1504/files

I'd like for someone from the charts team to review my PR first, please, given that it has been there for about a month now.

@unguiculus done with your requests. @bbriggs I agree, any idea what the current state is and why?

@alejandroEsc I popped into the Helm core dev meeting a couple weeks ago to request review after it sat idle for 8 days and got a promise to review it. However, there has been no movement on it since. They did say they wanted to "evaluate the full stack" meaning kuernetes-vault + the kubernetes PR someone else submitted.
However, I'm pretty disappointed by the handling and lack of attention to PRs so far. I've been trying to be patient and wait for things to resolve given that this is my first PR here and I don't know what's normal or processes that are expected, but this is more than frustrating that work gets ignored to the point that work is now being duplicated.

@bbriggs yeah it is frustrating, ill see if i can contact a few people there and get your PR moving.

@bbriggs Sorry, I probably misunderstood. I won't close your PR then. I'll check back with @lachie83 to see if we can get this through.

Can we close this PR, now that #1396 was merged?

@unguiculus I appreciate the politeness of you asking. Yes please do, any further work will be submitted against current vault chart :) Excellent job @bbriggs and i hope you continue to contribute!

Looking forward to it. If you want to make some improvements to the k8s-vault chart, feel free to ping me. I'd love to collaborate on it.