feat(quill_native_bridge): Add default native implementation of ClipboardService for Android, Linux, macOS, iOS, Windows and Web

Description
Add default native implementation of ClipboardService for Android, macOS, iOS, Windows and Web.
The rich text pasting feature is now working without super_clipboard using only flutter_quill without any external dependencies, no need for installing Rust or anything extra, bridges that could make the app a bit slower to start initially.
Rich Text Paste Flutter Quill Example

The example above doesn't call this method from flutter_quill_extensions:
FlutterQuillExtensions.useSuperClipboardPlugin()

Videos

https://github.com/user-attachments/assets/1cfd86b5-d74e-439f-9f84-716803475ae9
https://github.com/user-attachments/assets/5cc4ccbb-2f12-49be-80bd-16c85c84bb53
https://github.com/user-attachments/assets/dd178190-d5f3-47e5-8105-26c42426aaaa

Manually tested on both real device and emulator/simulator.
The android directory has been added using flutter create -t plugin --platforms android --org dev.flutterquill . for quill_native_bridge for the Android implementation, however, this command also make/revert some other changes to the ios directory which are not related, I removed them previously.
Same thing for macOS.
Related Issues

Partial Fix #2229
Partial Fix super_native_extensions Issue #435 for quill_native_bridge only
Partial Fix #2243
Related #2220
Related #2009

Type of Change

[x] ✨ New feature: Adds new functionality without breaking existing features.
[x] 🛠 Bug fix: Resolves an issue without altering current behavior.
[ ] 🧹 Code refactor: Code restructuring that does not affect behavior.
[ ] ❌ Breaking change: Alters existing functionality and requires updates.
[ ] 🧪 Tests: Adds new tests or modifies existing tests.
[x] 📝 Documentation: Updates or additions to documentation.
[ ] 🗑 Chore: Routine tasks, or maintenance.
[ ] ✅ Build configuration change: Changes to build or deploy processes.

TODOS

[ ] Cleanup the code for native platforms
[ ] Cleanup the dart method channel code (MethodChannelQuillNativeBridge and related classes)
[ ] Remove optional template assets and files for the example of quill_native_bridge
[x] Retrieving HTML from the Clipboard on Android, iOS, and macOS.
[x] Copying an image to the Clipboard on Android, iOS, and macOS.
[x] Retrieving images from the Clipboard on Android, iOS, and macOS.
[ ] Retrieving gif images from the Clipboard on Android, iOS, and macOS. Was not able to support macOS since not natively supported same as iOS.
[ ] See and discuss if getClipboardImage should or should not return a Gif file, if not, should getClipboardImage fall to returning the Gif image in case of unsupported operating systems (macOS only until now)? Related #1788.
[x] See if there is a need for moving the web implementation into its own package (quill_native_bridge_web and quill_native_bridge_platform_interface), also we might consider throwing assert failure on all methods in case of web in MethodChannelQuillNativeBridge.dart since will use QuillNativeBridgeWeb for the web. Web implementation has been separated into its own package. quill_native_bridge_platform_interface is not available yet as this package is in the early stage and breaking changes can happen.
[x] Configure the flutter_quill example AndroidManifest.xml to support copying images to the clipboard.
[x] See if retrieving Markdown from the clipboard is a standard feature on all platforms or if there is a use-case to it. Doesn't seem to be a standard feature on most platforms.
[x] See if retrieving HTML and Markdown files is a standard feature on all platforms or if it's a desktop-specific feature Seems to be a desktop-specific feature, AFAIK is not supported on Android desktop mode.
[ ] See if we need to separate retrieving PNG images from GIF images, currently, we have different methods getClipboardImage and getGifImage but they can be in the same function and will always return the image regardless of what it was. We probably do want to separate them so that users can have separate implementations for onImagePaste and onGifPaste
[ ] Review the Clipboard Impl for Android, and see where we would use coerceToHtmlText(), currently we're always retrieving the first item.
[x] Might implement a new feature which is copying Delta as HTML to the system clipboard to paste it for other apps (might not do it for now or only for example). The copyHTMLToClipboard has been added but is not used in ClipboardService.
[x] Simplify ClipboardService
[ ] Fix issue #2220 for web
[ ] Might update #1722 only to fix the bug for Safari instead, discuss the change first. Seems to be unrelated.
[x] See which features can be implemented on the web and the restrictions, we probably will use the Clipboard API on all browsers that support it and fall back to events (such as paste event) for Firefox. Retrieving GIF images from the clipboard is not supported on the web. Was able to use the Clipboard API instead of fallback to Clipboard events on Firefox without any issues. See #1998
[ ] Update docs and references to super_clipbaord in flutter_quill and flutter_quill_extensions, will probably use the new impl as a default for the example.
[ ] Discuss if we need to introduce a breaking change for flutter_quill_extensions to move super_clipboard into its own package or provide an example code instead.
[x] See Flutter #127396 and decide if we should use the base keyword (introduced in Dart 3) or stick to plugin_platform_interface for quill_native_bridge (will probably do) Since no decision has made by the Flutter team yet, and haven't discussed this change, decided to stick to plugin_platform_interface for now.
[ ] Update the minimum version requirement of quill_native_bridge and flutter_quill_extensions in flutter_quill once done before publishing a new release.
[x] The ClipboardService and related classes should be experimental for now by adding a comment and experimental annotation. We may consider removing ClipboardServiceProvider and accessing the instance directly from ClipboardService if being experimental is the only issue.
[ ] Add the option to not use some of the features in this PR.
[x] Add basic integration tests for at least some of the functionality.
[ ] Check the format of Kotlin, and Swift in GitHub workflow.
[ ] Currently on Android, will return the HTML/Image from the primary clip item (the last item has been copied), if the user copies HTML, then an image, and if getClipboardHTML was called after that then will be null since that's not the last/primary item (which is the image in this case). We should take this into consideration and if it's the behavior that we expect.
[x] Separate the plugin platform interface from quill_native_bridge
[ ] Provide a different way to check the platform support for a method so that implementations of QuillNativeBridgePlatform (outside of quill_native_bridge) can decide if its unsupported feature, if we update a package implementation (e.g. quill_native_bridge_windows) and add support for a method, updating quill_native_bridge or quill_native_bridge_platform_interface is not required. Allowing to check if Clipboard API is supported in QuillNativeBridgeWeb.
[ ] Improve the error handling in general, throwing exceptions instead of using asserts in quill_native_bridge_windows, quill_native_bridge_linux.

Support for Windows is very limited and highly experimental, likely to have issues. Support for Linux is still under consideration and might be in a separate PR once most of the known issues are solved.

While trying to add support for onGifPaste (introduced in #1788) and it seems to not be a feature that's supported natively on macOS. Copying GIF image using Google Chrome on macOS and then printing the available pasteboard types:
[__C.NSPasteboardType(_rawValue: public.png), __C.NSPasteboardType(_rawValue: Apple PNG pasteboard type), __C.NSPasteboardType(_rawValue: public.html), __C.NSPasteboardType(_rawValue: Apple HTML pasteboard type), __C.NSPasteboardType(_rawValue: org.chromium.source-url), __C.NSPasteboardType(_rawValue: public.tiff), __C.NSPasteboardType(_rawValue: NeXT TIFF v4.0 pasteboard type)

Doesn't seem to be supported by super_clipboard either.

I will probably separate the implementation into different packages for a more scalable solution, I did want to have things as simple as possible (not necessarily simple, only as simple as possible and as complex as needed).
The Windows implementation will probably require conditional imports (win32, ffi) and probably will be in Dart code. For the web, there is a lint warning that need to be ignored (either from analysis_options.yaml or ignore: avoid_web_libraries_in_flutter for each file), for Android impl there are warning and error handling that are only Android side and will not be used on the other platforms (will not separate the Android impl into quill_native_bridge_android due to this reason, will keep it in quill_native_bridge). If someone wants to provide their own implementation then we also need to provide them quill_native_bridge_platform_interface and will be required for quill_native_bridge_web and quill_native_bridge_web.
This will complicate the usage for the users since they can still use quill_native_bridge directly.

Renaming the plugin from quill_native_bridge to quill_native_integration can take some time and is error-prone process, so decided to delay it later, as for the web package, instead of creating quill_native_bridge_platform_interface I decided to only have quill_native_bridge_web,  quill_native_bridge_windows for now. For Linux still haven't decided if the implementation will be in Dart or platform native code.
Those packages will depend on quill_native_bridge.

@CatHood0 @AtlasAutocode @singerdmx
I decided to move quill_native_bridge outside this repo for the following reasons:

The version is now separated, when a breaking change introduced in flutter quill it doesn't affect quill_native_bridge and vice versa. Also we may want to have pre-release of one package and not the owner.
Integration tests are time-consuming and expensive since they will run in the example on a real device, I only wrote a few simple tests for quill_native_bridge, since this is a plugin, it will run on all platforms in CI, including older versions of Android to ensure compatibility as some of the logic work slightly different based on the Android API. The rest doesn't require this but still need to be tested on various versions or at least the latest version. Most of the time we don't work on quill_native_bridge so running each commit will run the check.
Separate the issues, we currently have high amount of issues, I have closed around 50-100 issues in 2023 only because they are outdated (which shouldn't do) and we still have a lot of issues, even if not reported, not all users do report them. So we don't want to have more issue reports directly in here.
Conflicting with CI, quill_native_bridge has different requirements, and for unknown reason, the workflow used the latest.
A separate example and it has its own packages and level of complexity that we don't need here. We only need to know that QuillNativeBridge.getClipboardHTML returns HTML from the clipboard when available here. We do need to test the changes on the example we have for Flutter Quill but if an issue happened and didn't in that example, it's a usage or Flutter Quill issue and should be fixed separately.
version of quill_native_bridge (that's published and hosted on pub.dev only for a reason) when the latest version is 10.5.4 and is used in pubspec.yaml. Changes of this branch is still not merged so the example don't know about them, I'm still not sure why however it's better if we move it completely out of this repo to ensure such issues don't exist. See #2264 where the issue occurred. I wasn't able to have this issue previously when I first introduced a related change.

I decided to move quill_native_bridge outside this repo for the following reasons:

The version is now separated, when a breaking change is introduced in flutter quill it doesn't affect quill_native_bridge and vice versa. Also, we may want to have pre-release of one package and not the owner.
Integration tests are time-consuming and expensive since they will run in the example on a real device, I only wrote a few simple tests for quill_native_bridge, since this is a plugin, it will run on all platforms in CI, including older versions of Android to ensure compatibility as some of the logic work slightly different based on the Android API. The rest doesn't require this but still needs to be tested on various versions or at least the latest version. Most of the time we don't work on quill_native_bridge so running each commit will run the check.
Separate the issues, we currently have high amount of issues, I have closed around 50-100 issues in 2023 only because they are outdated (which shouldn't be done) and we still have a lot of issues, even if not reported, not all users do report them. So we don't want to have more issue reports directly in here.
A separate example and it has its own packages and level of complexity that we don't need here. We only need to know that QuillNativeBridge.getClipboardHTML returns HTML from the clipboard when available here. We do need to test the changes on the example we have for Flutter Quill but if an issue happened and didn't in that example, it's a usage or Flutter Quill issue and should be fixed separately.
Conflicting with CI, quill_native_bridge has different requirements, and for unknown reasons, the workflow used the latest version of quill_native_bridge (that's published and hosted on pub.dev only for a reason) when the latest version is 10.5.4 and is used in pubspec.yaml. Changes of this branch are still not merged so the example don't know about them, I'm still not sure why however it's better if we move it completely out of this repo to ensure such issues don't exist. See #2264 where the issue occurred. I wasn't able to have this issue previously when I first introduced a related change.

I didn't want to create a new repo in my GitHub account for the following reasons:

I do change my username from time to time
At some point, the new repo will be controlled by someone else, having it in my own personal account is not future-proof.
We're creating different repositories now, having all related repositories in one place is useful for organization.
It also can give the user a better experience.

@CatHood0 @AtlasAutocode
I sent you invites to @FlutterQuill in case you're interested. We have not decided if we will move this repo to the new organization. I wanted to create an organization though the FlutterQuill was already used, asked @singerdmx and it seems it's already created so decided to stick to it instead of choosing a different name. We might have more than 1 or 2 repositories in this organization on the long term but this is not a priority at the moment.

While writing some integration tests, the tests were failing when I added copyHTMLToClipbaord, it seems I accidentally (using something with the IDE) changed something while adding this feature causing a minor bug on all platforms, was able to catch this bug while writing the test itself which prove we really need some tests at some point.
Writing tests for Flutter Quill is not as simple as here since this is a new feature designed and meant to be tested that I'm familiar with, making it much easier to write. More discussion regarding the test situation will be in a separate issue in the future.

While introducing the Windows implementation of the plugin, I separated it from quill_native_bridge (quill_native_bridge_windows) and decided to implement it as a Dart plugin (in dart code) with ffi and win32. I attempted to use the win32_clipboard package for high-level clipboard access. However, I couldn't retrieve the HTML since it always cast the data to UTF-16 (see this line) and HTML on windows is always using UTF-8 encoding which result in a strange text that look like Chinese (doesn't have any known language). Refer to HTML Clipboard Format
Description for more details.
As a result, I opted to work directly with the Win32 API for a low-level implementation, I'm unfamiliar with Windows Win32 and this is my first time using their API, tested it on Windows, and it seems to work fine.
I noticed the clipboard content is not available even after copying HTML when setting the clipboard mode to Bidirectional in Virtual Box, There may be additional steps needed to reproduce this issue on Windows, so this is a highly experimental implementation. I'm uncertain if opening the clipboard by a program prevent others from accessing the clipboard on Windows and is expected behavior.
@AtlasAutocode I recall you mentioned you have used Win32 before. If you have time, could you review the quill_native_bridge_windows implementation, focusing on the Win32-specific code? To check for stability and quality, and suggest any improvements. There’s no rush—if you need more time, we can separate the Windows support into a different PR or release it as highly experimental, without making it the default package in quill_native_bridge. We can also delay merging this PR and focus on other tasks.

I looked through the win32 code for accessing the clipboard and did not see any obvious problems.
Your code matches what I use in C++/win32 apps.
I am not as familiar with the dart interface but it looks like you are correctly using calloc.free to recover stack allocated memory allocations that could result in memory leaks. And I don't see any places where lock/unlock are mismatched or missing.
Converting between UTF8 and UTF16 will need testing but that should not be difficult if we create an HTML document with a couple of Unicode characters and make sure they come in correctly. Unit tests should be able to do this.
CloseClipboard is important to allow other windows/apps to access the clipboard. I've never found this necessary, but you could enclose in try-finally to ensure the clipboard is released even if an exception is thrown.
I might be concerned if the clipboard html did not include the <html> tag but it looks like your code would not have a problem. My guess is that there might be other (undocumented?) meta tags before <html> but I don't know how to handle that if you also have to cope with possible missing <html> tag. Perhaps you could scan the lines, stop at the <html> and then delete all preceding lines or copy all following lines? I don't know how the clipboard (or us?) decides that the input data is html - if the <html> tag is not found then would it be processed as html?
Do you have to cope with <HTML> (wrong case)? According to the HTML5 specs, html is not case sensitive and it is legal to use tags with different upper/lower case. I wish dart had a case insensitivity setting but I understand this is a problem for non-English languages.
Minor comments:
RegisterClipboardFormat for HTML can be const/static. It is one of the small number of formats that are pre-defined in windows and does not ever change. As such, it should never be zero.
Other comments:
EnumClipboardFormats and GetClipboardFormatName might be useful. I've not used them since mostly I am exporting data to the clipboard to be used in other apps.

could enclose in try-finally to ensure the clipboard is released even if an exception is thrown.

I considered this but it seems it doesn't throw any exception, I checked it and it seems that the error will be handled using GetLastError() or a similar function, of course, the current code is not scalable enough to have more features, and should be more organized which is I put 4 TODOs to confirm this, to make sure we don't forgot about the issue and then merge directly while the issue is here somewhere in GitHub.

My guess is that there might be other

There is a comment but it's valid and should be ignored, I already pasted the HTML in Quill JS Playground, and seems correct, though haven't in the Flutter Quill example since I'm using VirtualBox in Linux distro and I'm having a build failure related to Rust and Cargo, it seems that installing Rust on windows sometimes can't be automated, haven't tried further since I already have others tasks.

stop at the  and then delete all preceding lines or copy all following lines

The code currently will remove all those lines related to description headers if they exist, once we reach the ` tag or there are no longer description headers it will break the loop and then return the HTML directly. I have added some minor tests and it seems that some HTML parsers do throw errors when there are such comments that are not valid HTML, and some do try to parse it anyway, causing unexpected behavior or adding those comments somewhere inside the HTML.

Do you have to cope with  (wrong case)? According to the HTML5 specs, HTML is not case-sensitive and it is legal to

If you mean this part:
 bool isHTML(String str) {
          final htmlRegExp =
              RegExp('<[^>]*>', multiLine: true, caseSensitive: false);
          return htmlRegExp.hasMatch(str) && str.startsWith('<');
        }

        expect(isHTML(clipboardHtml), true);
        expect(isHTML('Invalid<html></html>'), false);

Then it's already not case sensitive, it will run as an integration test to ensure Windows and all other platforms implementations do return HTML that can be parsed and doesn't include non-HTML content/comment as leading. I didn't see a need for this test until I saw this.

RegisterClipboardFormat for HTML can be const/static

I'm not sure what you meant, do you mean the format ID itself can be static/const:
extension type const ClipboardFormatExt(int formatId) implements CLIPBOARD_FORMAT {
  static const CF_HTML = 49320;
}

Or:
static const kHtmlFormatId = 49320;

If that's the case, then why RegisterClipboardFormat is needed to be called? Does it only return the ID or register that format and then return the ID? The win32 package docs:
/// Registers a new clipboard format. This format can then be used as a
/// valid clipboard format.
///
/// ```c
/// UINT RegisterClipboardFormatW(
///   LPCWSTR lpszFormat
/// );
/// ```
/// {@category user32}
int RegisterClipboardFormat(Pointer<Utf16> lpszFormat) =>
    _RegisterClipboardFormat(lpszFormat);

final _RegisterClipboardFormat = _user32.lookupFunction<
    Uint32 Function(Pointer<Utf16> lpszFormat),
    int Function(Pointer<Utf16> lpszFormat)>('RegisterClipboardFormatW');

EnumClipboardFormats and GetClipboardFormatName might be useful.

Thank you for mentioning them, I will see where they might be used.
In general, I'm okay with implementing the core clipboard operations that we need in quill_native_bridge_windows though I will most likely need your review and help on any related changes, prefer to not release something that I just used as stable to the public. This is my very first time using Win32 and I don't remember the last time I used C++. It doesn't have to be ASAP, the one feature that I do plan at the moment other than clipboard is the spell checking which is supported only on Android, iOS, and macOS which make require less effort to implement.

Do you have to cope with (wrong case)? According to the HTML5 specs, HTML is not case-sensitive

I was referring to the code that uses <html> lower case:
for (final line in lines) {
    // Stop processing when reaching the start of actual HTML content
    if (line.startsWith('<html>')) {
      break;
    }

why RegisterClipboardFormat is needed to be called?

It does need to be registered but registration only needs to be done once when the format is first needed. No need to call it every time you access the clipboard. From the docs, once a format is registered with the computer, any subsequent access from this or any other app will return the same number. This is so that different apps can exchange data in the specific format.
When you restart your app, you again need to register the format to be able to access that format on the clipboard.
When windows restarts, its current table of registered formats is cleared.
Trivia: for HTML the returned registration ID is the same for all computers. For other formats the number can/will be different on different computers.
I use a global (late static final?):
extern "C" UINT CF_REG_HTML = ::RegisterClipboardFormat ( _T("HTML Format") );
and then just use CF_REG_HTML whenever needed. OpenClipboard is not needed to register, and I have never seen it fail for HTML.

I was referring to the code that uses  lower case:

Good catch, should not be case sensitive. If  the input was <HTML>, then this loop will continue until the end of the HTML. Will add one more test to cover this case.

Just as a comment:

Support for Gif on Linux

Gif is not common on Windows. Windows clipboard primarily uses BMP and vector metafiles (wmf, emf). PNG, TIFF or JPEG for files.
Using the win32 dart package would enable access to the windows clipboard formats but then we would need a way of viewing or converting.
I think clipboard image support is going to be very platform dependent. My own interest is in cross platform support where the same shared document file can be viewed on different platforms. Images cannot be saved as temporary files.

@CatHood0 If you have the time, can you test the example of quill_native_bridge or flutter_quill on your Linux distro to see if it works properly? It should work on most major Linux distros except those who use Wayland. Currently, the implementation only supports X11, and Wayland's support will be soon.
If we can complete the support for Windows (even if highly experimental), we can remove super_clipboard without worrying about having to move it into a separate package or publish a major release due to breaking changes in flutter_quill_extensions.
As for now, we will need to improve the code quality and readability before adding more features.

@AtlasAutocode
When you have the time, can you review copyHtmlToClipboard()? I'm unfamiliar with Win32 and this is actually the first time most of the things I done here either which is why I shifted Windows support to be the last, I have used Windows Docs and win32_clipboard as a reference and I can see issues, especially quality issues, with this implementation, it could really use improvements, ignore the usage of assert as I will throw exceptions though that will be later once address some things.
The naming could really use improvements, following naming conventions to be more clear

I'm not sure about the conventions when using Dart FFI with Win32, since this Dart project should at least make it easier for developers who are not familiar with other languages or make it more clear, see this example in Kotlin with Android (quill_native_bridge_android):
@ConfigurePigeon(PigeonOptions(
  dartOut: 'lib/src/messages.g.dart',
  // Using `GeneratedMessages.kt` instead of `Messages.g.kt` to follow
  // Kotlin conventions: https://kotlinlang.org/docs/coding-conventions.html#source-file-names
  kotlinOut:
      'android/src/main/kotlin/dev/flutterquill/quill_native_bridge/generated/GeneratedMessages.kt',
  dartPackageName: 'quill_native_bridge_android',
))

You can see this commit. This is not final yet though I'm looking forward to your feedback as you're already familiar with Win32.
copyHtmlToClipboard() is currently not used in flutter_quill and we have no plans of using it until now however I have found it useful in integration tests and that's the main reason I'm implementing it, I don't plan on implementing anything related to windows other than copyImageToClipboard and getClipboardImage so once things are more stable and organized, we won't introduce much changes as we don't need to (at least not for Windows). Those are already used in integration tests and I depend on tests (in addition to manual tests) to ensure to not introduce regressions. Also, it can be considered a breaking change if we release a new version that uses quill_native_bridge that lack Windows support when it was supported using super_clipboard which I prefer not to introduce a new major release to remove super_clipboard and ask users to add a new package for super_clipboard to migrate as we have done many breaking changes.

All locked memory allocations must be unlocked before their data handle is used.

I highly doubted there is an issue since I didn't clearly read the docs so left a TODO with a reference,
is what they meant that we should not call GlobalFree before or after SetClipboardData since the system will take ownership of the memory as it expects the GLOBAL_ALLOC_FLAGS.GMEM_MOVEABLE?

fails, then call GlobalFree to release the allocated memory. If it succeeds, then the clipboard owns the data and it should not be freed.

Thank you for clarifying, already got the answer to my previous question. Can you review this commit addressing those issues with minor change? I'm uncertain if we should GlobalUnlock the clipboardMemoryHandle or lockedMemoryPointer. I have looked into some Flutter plugins that use win32 and I have seen similar issues even though the code work without any issues, runtime, or compilation issues which is common in low-level languages and unexpected in languages like Dart.

According to GlobalUnlock function Windows docs:

Note  The global functions have greater overhead and provide fewer features than other memory management functions. New applications should use the heap functions unless documentation states that a global function should be used. For more information, see Global and Local Functions.

Should we use those new heap functions instead? Since we don't have complex requirements that need low-level access, in general, I'm looking to use the most up-to-date methods since Flutter desktop supports Windows 10 and newer versions, you might noticed that I used version 1.0 instead of 0.9 for the Windows HTML Clipboard Description headers in constructWindowsHtmlDescriptionHeaders()

Updated in this commit. Are there any changes or improvements specific to accessing the Win32 API or related memory management issues?

The global functions have greater overhead

Yes, that is true but not relevant to your use case.
You MUST use global functions since you are transferring data from your app to the global windows environment (aka the clipboard). This also ensures that the data is available even after you close the source app.
For apps that use data internally, you would not use global functions. Local or heap-based allocations are faster but only accessible from within the app.

used version 1.0 instead of 0.9 for the Windows HTML Clipboard Description headers

You might want to be careful here. It sounds like a good idea but might have serious unintended consequences. There is a lot of antique inherited code dependencies. win32 is still a main windows interface for desktop. But Microsoft has been trying to eliminate it with .Net and UWP (not successfully!). The advantage of win32 (notice there is no win64!) is that it provides low level access to all windows operating system functions and is not going away for many years. FYI: Microsoft is trying to transition all users to cloud. You will be able to run windows apps from any computer (mac, linux, mobile) by running it on a cloud-based interface.

internal utility function

I think this is more likely to cause a failure to unlock, but this is your call. I generally try to keep it simple:
processingFunction ( GlobalLock(handle) );
GlobalUnlock(handle);

.net programming has a very useful function
using ( var pointer = accessFn() ) {
  do whatever with pointer.
}

Within the block you can use the pointer and when the block ends it automatically releases/disposes of what was done in the using clause.

might have serious unintended consequences.

Sure though this is usually when having compatibility issues with older versions, most apps already support version 1.0 and the Flutter team has already dropped the support for Windows 7. So there is probably not much to lose or have when using new version, IMO using new methods should not be on the account of having less backward compatible product, this is an example on Android though this Windows case is different.

Microsoft has been trying to

If you want my personal opinion, Windows itself as an operating system is no longer that functional as it's used to be in Windows 7 and older versions, full of bugs and issues, and not as performant as before in even if you have the best hardware. Those new apps such as the Microsoft Store are commonly known to be buggy, though this is another topic that's not quite related to our discussion.

I think this is more likely to cause a failure to unlock,

This is why I avoided it, it needs more testing and has less control, there are probably other issues that I'm not aware of.

it automatically releases/disposes of what was done in the using clause.

Similar to the use block in Kotlin which is also compatible with JVM.

Similar to HTML, we can't directly copy the input to Windows clipboard, which will cause the image to be invalid when pasting into other apps, not being pasted or missing. It seems that we need to use either either CF_DIBV5 (extended version of CF_DIB) or CF_DIB. Supporting those formats require more testing, conversation, and search about this, assuming that the image we're copying is PNG, then we need to decode it and encode it to Windows BMP, which is what I did and it still not copying properly, and it also require image as a dependency, adding new dependencies to the Flutter Quill project is something I highly prefer not to unless it's needed like win32.
According to the Win32 (which I need to read more about it), it looks like we need some additional work, maybe some headers similar to HTML, I have looked into BITMAPINFOHEADER and BITMAPV5HEADER and it seems that currently only definition of BITMAPINFOHEADER is available in win32.

As I'm unfamiliar with those and new to Win32 (once again, this is my first time to clarify), I don't want to introduce a feature that I just implemented for the first time for Windows as a stable feature, and I'm unable to support it due to the lack of time, also users still having build failure issues with super_clipboard, introducing a breaking change (not supporting those anymore when it was stable with super_clipboard) is still not an option yet so I have to use Process and copy the image using Windows Powershell, what we will use should be available in Windows 7 and newer version, shouldn't cause compatibility issues, not really the most efficient way though it should work for now.

Doesn't seem to be a good solution:
Future<void> copyImageToClipboard(Uint8List imageBytes) async {
    final tempClipboardImageFileName =
        'tempClipboardImage-${DateTime.now().millisecondsSinceEpoch}.png';
    final tempImageFile =
        await File(generateTempFilePath(tempClipboardImageFileName))
            .create(recursive: true);
    try {
      await tempImageFile.writeAsBytes(imageBytes);
      final powerShellScript = '''
Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing

\$imagePath = "${tempImageFile.path}"
\$image = [System.Drawing.Image]::FromFile(\$imagePath)

[System.Windows.Forms.Clipboard]::SetImage(\$image)

\$image.Dispose()
''';
      final result = await Process.run(
        'powershell.exe',
        ['-Command', powerShellScript],
      );
      final exitCode = result.exitCode;
      if (exitCode != 0) {
        final errorOutput = result.stderr;
        // Handle output error
      }
    } on ProcessException catch (e) {
      // Handle process error
    } finally {
      await tempImageFile.delete();
    }
  }

Running PowerShell commands and scripts seems to be noticeably slower, it can take up to 0.5 to 3 seconds to copy the image, which feel like sending a network request rather than copying small and simple image, I'm running Windows as Virtual Machine though in general PowerShell is slower to handle those operations in an application regardless of how I'm running Windows or how running this process can be improved. I tried running the PowerShell script directly using Windows and I haven't noticed much of a difference.
Maybe there is another way.

I'm thinking about splitting the features of the quill_native_bridge package into different packages, so having:

quill_clipboard and related packages such as quill_clipboard_interface, quill_clipboard_android and the others.
quill_spell_checker and related packages such as quill_spell_checker_platform_interface, quill_spell_checker_android and the others.
other packages such as keyboard events (not available yet)

Each one will be in its own repo, this will make, in general, the project more scalable since we no longer need the clipboard word in the context of QuillClipboard (getHtmlText directly instead of getClipboardHtmlText), the error handling will be different and easier, and the platform check will also be different allowing us to have more control and being more specific about each feature, better compatibility, though do we want that level of complexity? Currently, we have 8 packages just for one package that contains native features. I will keep it simple for now and later we might want to more consideration this, since this package is for internal use only specifically for flutter_quill, this will make it easier for us to handle breaking changes.

I'm trying to provide the option to customize the clipboard paste behavior, we have pasteText() in QuillRawEditorState and clipboardPaste() in QuillController.
Where should the option to customize the paste completely be provided?
Noticed that the clipboardPaste() handle:

Internal image paste
HTML and Markdown rich paste
Plain Text Paste
Provide support for the onClipboardPaste callback which will be used if none of those are available, we should instead provide something to completely override this behavior, we should expect either true or false in that callback and will be used at first, if true is used mean it's being handled as expected, if false then it means that the user wants to fallback to our default handling. It's similar to the , similar to customVideoBuilder which except a value and return null instead of false. Maybe we want a more advanced approach for further customization, we want to know if the user wants to fallback to our default handling, or use their own and see if the operation was done successfully or not, the user should be able to decide if they want to call bringIntoView(textEditingValue.selection.extent) on success or failure, so we might use enum or sealed class instead of true and false, which will also make it more readable and easier to understand.

The pasteText():

Will return if the editor is in read-only mode
Call clipboardPaste() and return if the paste operation is called successfully.
Them attempt to use onImagePaste and onGifPaste, which won't call bringIntoView(textEditingValue.selection.extent) in case of success.

We need to know why those are separated into different two places.
@singerdmx  @AtlasAutocode @CatHood0 What do you think?

Sure, I didn't mean to ask for a review too many times (I haven't noticed that), for the last 2 or 3 weeks I've been working full-time on the project and I want to finish this PR to move on to many more important issues.
I will try to ask for review less often if time is limited. I will still work more on the project for a short time and submit more changes.

I thought we agreed to not add new features.

I assumed we agreed on stabilizing the project and fixing issues, docs, tests, code cleanup and refactoring, and maybe extensibility with a proper architecture so we don't have to add new features directly in the project (if users need them), and more.
This is not a new feature, it's a bug fix by introducing a feature that we implement ourselves instead of relying on super_clipboard which we're still getting reports about build failure, bundle size, higher minimum SDK requirement for Android which is causing issues for existing published apps, some rare crashes and other issues.
I do consider it critical though I will split this package into its own repo (due to requirement of running integration tests and other reasons) so minimal changes will be made on this repo. It will be moved soon to FlutterQuill/quill-native-bridge.
The feature PR we discussed is already closed, and I'm starting to close feature requests that we don't have a plan to work on. Already added a note in README.md indicating that adding new features is currently not our first priority.
I thought we were interested in achieving that challenge. I'm open to feedback and to collaborate with anyone who is interested in that challenge, though it's not an easy task and will require an extensive amount of time. We need a plan if we're going to work together otherwise.
Unfortunately, I don't have time either. Though more on this discussion will be in a separate thread.

I usually prefer more code review though we need to prioritize other issues.

Noticed that the clipboardPaste() handle:

Internal image paste
HTML and Markdown rich paste
Plain Text Paste
Provide support for the onClipboardPaste callback which will be used if none of those are available, we should instead provide something to completely override this behavior, we should expect either true or false in that callback and will be used at first, if true is used mean it's being handled as expected, if false then it means that the user wants to fallback to our default handling. It's similar to the , similar to customVideoBuilder which except a value and return null instead of false. Maybe we want a more advanced approach for further customization, we want to know if the user wants to fallback to our default handling, or use their own and see if the operation was done successfully or not, the user should be able to decide if they want to call bringIntoView(textEditingValue.selection.extent) on success or failure, so we might use enum or sealed class instead of true and false, which will also make it more readable and easier to understand.

The pasteText():

Will return if the editor is in read-only mode
Call clipboardPaste() and return if the paste operation is called successfully.
Attempt to use onImagePaste and onGifPaste, which won't call bringIntoView(textEditingValue.selection.extent) in case of success.

Our current design is inconsistent, there is also a bug (before and unrelated to this PR), Clipboard.getData(Clipboard.kTextPlain) is not reliable (see issue #2323) and will always try to return plain text, the behavior is platform-dependent, on iOS if you copy an image from the browser and then paste, with our current code it will paste the image URL (from the network) instead of paste the image even if it's available, that's because we currently prefer Clipboard.getData(Clipboard.kTextPlain).text over onImagePaste and onGifPaste.

The solution is to either:

Provide a new platform method getClipboardText() in quill_native_bridge and ensure to only return a String if there is a plain text clipboard item, not another item, and then cast it, super_clipboard also has this functionality.
Change the order of the handling

In either case, we will need to refactor some things in version 11.0.0 since some things are broken and we still need to provide a way to customize the clipboard behavior, it's a commonly requested feature and it will allow the user to override the default if there is a bug (which currently have some bugs) or if the user doesn't want the default.
@AtlasAutocode When you have the time, can you explain the design and why pasteText() and clipboardPaste() are different (as you separate them in #1843)?

pasteText is in the editor and should only call the controller's clipboardPaste function. I see no reason for pasteText to call clipboard image functions directly. Presumably this is historical code left so as not to introduce a breaking change.

Thanks for the reply. The pasting image was supported initially with pasteboard, then I removed it and introduced super_clipboard in 11.0.0 I'm still unsure about the new behavior.

Presumably this is historical code left so as not to introduce a breaking change.

I'm still not sure how will we handle this in 11.0.0, passing the editor config to the controller and accessing it from there is something I want to avoid since we haven't understood the existing structure properly, how about we move the clipboard paste function back from the QuillController to where it was so we don't have to move onImagePaste and onGifPaste to the controller config?
This feature can still be implemented without having to provide the clipboardPaste() in the controller, instead, we can only provide the internal image and delta stored within the controller.


Add keyword completions for try/catch/throw/continue

From https://github.com/PowerShell/vscode-powershell/issues/703.
PowerShell apparently offers completions for some keywords, but not:

try
catch
finally
continue

Providing these would improve script authoring experience

Tangentially related and in the same vein as #7828 -- would be nice to have completions for all common error handling cases. 😄

I would also request adding to this keywords for:

begin
process
end

As autocompletion when writing these blocks for advanced functions frequently populates the editor with unintended code.


Allow execution of included OCaml code blocks

This PR allows to execute OCaml code blocks.
This is useful whenever someone wants to separate the actual code from the mdx-experiments on it.
For instance:
(** file.ml *)

let rec compute = [%something]

<!-- mdx_doc.md -->

Here is the code of the function we are studying:
```ocaml exec,file=file.ml
let rec compute = [%something]
```
This function is very interesting!
```ocaml
# compute 1 ;;
- : int = 2
# compute 2 ;;
- : int = 1
```

Without this PR, we would have an "unbound value" error for the compute function. This will prove especially useful for the odoc reference driver.
I added a exec flag to execute an included code block only for backward compatibility.

I see the new flag has been added for retro-compatibility, but it sounds confusing to me to have the skip tag to not execute, and the exec tag to execute.
It sounds acceptable to me to make this a breaking change and make people add a skip tag to their existing blocks they don't want to execute. Are there some corner cases I don't see?

I would be very happy to remove the exec tag since I agree it's confusing!
However, there is a bit more "breaking changes" than what we first think:

Current behavior, for include blocks:

Skip tag is there: Do not include the content from the file
No tags: include the content but do not execute

Behavior as of now in the PR, for include blocks:

Skip tag is there: Do not include the content from the file
No tags: include the content but do not execute
Exec tag: include the content and execute.

If we remove the exec tag, and always execute, we have two breaking changes:

No tags: include the content <span style="color:red>and execute it
A skip tag: we have two options here:

Do not include the content (the old "skip" behavior)
Include the content and do not execute it (the old "no tag" behavior)

If we do i. and do not change the "skip" behavior, it is not anymore possible to have the old "no tag" behavior: inclusion but no execution. If we go with ii. we can still have the old "skip" behavior by removing the "file" tag.
So what would you think of ii.:

Changing skipped inclusion of file to: include content but no execution
Changing inclusion of file to: include content and execute it

?
I'm happy with this, but I think it is quite a big breaking change for any code that has some side effects (such as creating a file, ...)

I have another suggestion based on the behavior of other kind of blocks.
I had a look in lib/test/mdx_test.ml and there is a check on the non-det option for ocaml/cram/toplevel blocks so that:

non deterministic command: skip everything
non deterministic output: run the command but keep the old output
deterministic: run as usual

Previously the non-det tag was not allowed for include blocks.
Now it would make sense, to evaluate and update by default, and then:

skip: don't include, don't do anything
non-det command: include, but don't exec, don't update the output
non-det output: include, exec, but don't update the output
otherwise, include, exec and update

That's a sensible idea. But I'm not super happy with reusing a command with an associated semantics (the fact that the output/command is non deterministic). In particular, the MDX_RUN_NON_DETERMINISTIC environment variable has an effect on those blocks, that we might not want in this case?
I think the combination skip + include in a block does not make sense (why specifying the include if we are going to skip it?) so I think it would make more sense to have "skipped blocks" include content but not execute it.
Note that it does not prevent you from using non-det on included code blocks! So, for include blocks:

skip: include, don't do anything
non-det command: include, but don't exec, don't update the output, unless MDX_RUN_NON_DETERMINISTIC or the --non-deterministic CLI flag is passed
non-det output: include, exec, but don't update the output, unless MDX_RUN_NON_DETERMINISTIC or the --non-deterministic CLI flag is passed
otherwise, include, exec and update
(Skip and no include tag: don't include, don't exec)

I implemented your suggestion. I had to add a disctinction on the ocaml_value type, either Impl or Intf, since we only want to execute implementations. I think it's ready for a first review.

I moved the ocaml_kind info like you suggested, and improved the tests. Let me know what you think!

I still think that skip should include the block, but not execute it.
In order to "skip" the inclusion, just omit the include directive! Using non-det flag is not possible since it has some other meaning and thus usecase (such as being sensitive to some environment variable).

I'm a bit concerned with breaking existing users. A search on github yields quite a lot of results which rely on the code not being executed:

Some side effects, such as line printing
Some code that expect user input/to be run on a terminal/loops and never return
Some code that requires JS stubs

So, I think the decision to do this breaking change is OK (mdx is still in early versions) but the change should be well communicated!

Hello! I think this change broke my build. Previously file parts, eg. in this README.md were not checked, but now I’m getting:
File "lang-shader-graphics/README.md", line 1, characters 0-0:
diff --git a/_build/default/lang-shader-graphics/README.md b/_build/default/lang-shader-graphics/.mdx/README.md.corrected
index 35fa4cc..1717a2e 100644
--- a/_build/default/lang-shader-graphics/README.md
+++ b/_build/default/lang-shader-graphics/.mdx/README.md.corrected
@@ -27,6 +27,10 @@ let scene : (vec3f repr) Env.t  =
   (* The final output colour to render at the current UV coordinate. *)
   Env.pure (background_color |> overlay ~shape:shape ~color:shape_color)
 ```
+```mdx-error
+Line 2, characters 28-33:
+Error: Unbound module Env
+```

 The resulting DSL is clunkier than I’d like. This is due to OCaml’s odd approach
 to custom operators (which don’t allow for custom precedences), and lack of

This is an issue if you want to include file parts where modules and definitions lie outside the code snippets. Is there a way to disable this behavior? I didn’t see any instructions in the changelog or README with guidance, so I’ve limited my MDX version for now, https://github.com/brendanzab/language-garden/commit/3e890a85814987f22de096c97a6e8abd7bfb1b46, following the example of the eio developers https://github.com/ocaml-multicore/eio/pull/706.

You can use the skip keyword:
- <!-- $MDX file=examples/Readme.ml,part=scene -->
+ <!-- $MDX file=examples/Readme.ml,part=scene,skip -->

@gpetiot, do you want to announce the release on discuss? It was suggested a few times already, and we can see it is not clear enough how to upgrade to 2.4! Also, mentioning skip in the changelog can be good as that's likely the first thing they'll look when breaking.

So, I think the decision to do this breaking change is OK (mdx is still in early versions) but the change should be well communicated!

Third, I'd recommend you mention the breaking change in some public space like discuss or the mailing list. That might save some headaches for some developers.

You can use the skip keyword:

Hmm, I just tried using skip, and does not seem to keep the file part in sync with the README – i.e. when I change the source file it does not result in an an error, requiring an --auto-promote to fix.
I had actually assumed this would be the case, which is why I didn’t think there was a workaround, but I should have checked and mentioned it when reporting!

Mmmh, I tried on your specific case, and it seems that doing dune clean followed by dune test does result in a failure diff.
However, without the clean before, it does not. Maybe you are missing a deps on Readme.ml your dune file? or should this be automatic? I don't know!

previously maybe the dune developers were thinking it meant “skip adding the file to the dependencies” or something.

Wait! It’s not dune, it’s part of how mdx collects dependencies!
https://github.com/realworldocaml/mdx/blob/bf33f76471d81d1e8313fbc5c2fd86a20ad96239/lib/dep.ml#L19-L26

This PR in its original form included a new exec flag to execute included block, so the execution used to be opt-in instead of opt-out. I don't know if we should revert to this version @gpetiot ?

Wait! It’s not dune, it’s part of how mdx collects dependencies!

Well spotted, thanks!

This PR in its original form included a new exec flag to execute included block, so the execution used to be opt-in instead of opt-out. I don't know if we should revert to this version @gpetiot ?

We can but it's gonna take some sweat since the commits have been squashed to clean up the history.


Add deterministic metric functions (standalone)

Add functions for computing deterministic forecast evaluation metrics, all of which are standalone functions (i.e. they only require as input the measured and predicted time-series, and do not perform any pre-processing of the data). In other words, these are the lowest level functions for computing the metrics, with the assumption that higher-level functions would call the functions as needed (e.g. after aligning and resampling time-series).
Current list of deterministic metrics:

[ ] mean absolute error (MAE)
[ ] mean bias error (MBE)
[ ] mean absolute percentage error (MAPE)
[ ] root mean square error (RMSE)
[ ] normalized RMSE (nRMSE)
[ ] centered (unbiased) RMSE (cRMSE)
[ ] Pearson correlation coefficient (r)
[ ] coefficient of determination (R^2)
[ ] Kolmogorov-Smirnov Integral (KSI)
[ ] the OVER metric (OVER)
[ ] forecast skill (s)
[ ] combined performance index (CPI)

Notes:

this issue is related to #4
a separate issue will be opened for tracking the probabilistic forecast metrics
other metrics may be added later

@wholmgren @alorenzo175 @lboeman I can't assign the issue to myself, but the point of me adding this issue is so that I can track my work on adding these functions (which I'll contribute via a MR once ready).

@dplarson I don't typically use the assign issues feature but we can if that's helpful. Do you prefer that we assign issues to for you? @awig?

@wholmgren In that case, no need to assign the issue. (I just wanted to make it clear I'll be working on this, to avoid duplication, and I'm use to using assigning as a way to track whose working on what.)


⚠ Bofrost.at has degraded performance

In 9b09769, Bofrost.at (https://www.bofrost.at) experienced degraded performance:

HTTP code: 200
Response time: 1187 ms

Resolved: Bofrost.at performance has improved in 9f8d6c1 after 4 hours, 41 minutes.


Limitations / nested nodes order

Is there any info on limitations of parentNode, currentNodes, futureNodes?
Eg. can currentNodes be not childNodes of parentNode, but some arbitrary set of nodes? Can they belong to different parents?
Can currentNodes include one another? Eg.
  let a = document.createElement('a')
  a.innerHTML = `
    <x><y></y></x>
    <z></z>
  `

  let x = a.querySelector('x')
  let y = a.querySelector('y')
  let z = a.querySelector('z')

  domdiff(a, [x,y,z], [y,z,x])
  a.innerHTML === `
    <z></z>
  <x><y></y></x>
  `

What's the logic behind this result? Is that expected? Another example:
a.innerHTML = `<x><y></y></x><z></z>`

  let x = a.querySelector('x')
  let y = a.querySelector('y')
  let z = a.querySelector('z')

  domdiff(a, [x,y], [y,z])

  console.log(a.innerHTML)  === `<z></z>` // y is missing

If currentNodes can be only childNodes of some parent - why API requires parentNode as first argument?
Is there any sense to add some explanation to these questions in the readme?
Thanks!

the domdiff utility must own the handling of the element content, and nodes must be those expected, meaning you cannot pass arbitrary nodes as list of current nodes, and nodes are handled only on the first level.
I suggest you don't use this library right away, but use lighterhtml, hyperHTML, or heresy instead, as it's obvious there how this library works, which is always by owning the nodes it populates, update, and change.
TL;DR no, you can't mess up with nodes, either one is fully handled by domdiff, or you are causing issues that wouldn't be there otherwise.


Disable internet access

Looking in Wireshark, it seems calling MangaOCR() makes various connections to https://huggingface.co/. How do I disable all these internet accesses? I do not see what purpose they have, since the library will work offline.

It seems that adding local_files_only=True to lines 17, 18 and 19 of manga_ocr/ocr.py works. Could this be made an option when initializing the library? Thank you!


Feat: Introduce Divider component #DS-1391

Description

Additional context

Issue reference

coverage: 78.783%. remained the same
when pulling fdd0ef2da469bc27962b6993b553e18f3e29956f on feat/ds-1391-stable-divider
into f0d30cf837a150ca8713bd8c1efdda3ccdf2878a on main.


Test explorer filter is prefilled with "run" in one project only

Issue Type: Bug
For quite some time now one of my python projects has suffered from this strange issue: Every time I open the project folder (or reload the window with this folder opened), and go to the test explorer, the filter is prefilled with the word "run", so only tests whose names contain that word are shown. I then have to manually delete the word in order to see all tests. Switching to some other view and back to the test explorer does not cause the problem to reappear. But next time I open this same folder, the problem is there again.
This only happens with this one particular folder. I tried making an exact duplicate of the folder, but the duplicate does not exhibit the problem.
I'm guessing that VS Code stores the UI state somewhere outside the folder, and that the state for this one particular folder has somehow managed to include a preset value for the test explorer filter field. I have no idea how this happened, nor how I can reset the UI state.
VS Code version: Code 1.68.0 (4af164ea3a06f701fe3e89a2bcbb421d2026b68f, 2022-06-08T11:42:10.176Z)
OS version: Windows_NT ia32 10.0.19043
Restricted Mode: No

System Info

Item
Value

CPUs
Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz (8 x 3392)

GPU Status
2d_canvas: enabledcanvas_oop_rasterization: disabled_offdirect_rendering_display_compositor: disabled_off_okgpu_compositing: enabledmultiple_raster_threads: enabled_onoop_rasterization: enabledopengl: enabled_onrasterization: enabledraw_draw: disabled_off_okskia_renderer: enabled_onvideo_decode: enabledvideo_encode: enabledvulkan: disabled_offwebgl: enabledwebgl2: enabled

Load (avg)
undefined

Memory (System)
31.95GB (26.61GB free)

Process Argv

Screen Reader
no

VM
0%

Extensions (34)

Extension
Author (truncated)
Version

Bookmarks
ale
13.3.0

xml
Dot
2.5.1

overtype
DrM
0.4.6

gitlens
eam
12.0.7

remotehub
Git
0.34.0

vscode-drawio
hed
1.6.4

wordcounter
kir
2.4.2

string-manipulation
mar
0.5.6

git-graph
mhu
1.30.0

python
ms-
2022.8.0

vscode-pylance
ms-
2022.6.10

jupyter
ms-
2022.5.1001601848

jupyter-keymap
ms-
1.0.0

jupyter-renderers
ms-
1.0.8

remote-wsl
ms-
0.66.3

anycode
ms-
0.0.67

anycode-c-sharp
ms-
0.0.5

anycode-cpp
ms-
0.0.5

anycode-go
ms-
0.0.5

anycode-java
ms-
0.0.5

anycode-php
ms-
0.0.6

anycode-rust
ms-
0.0.5

anycode-typescript
ms-
0.0.5

cpptools
ms-
1.10.5

hexeditor
ms-
1.9.6

remote-repositories
ms-
0.12.0

vscode-jest
Ort
4.6.0

showflags
pew
1.3.0

text-marker
ryu
1.11.0

vscode-fileutils
sle
3.5.0

rewrap
stk
1.16.3

open-in-browser
tec
2.0.0

selectline-statusbar
tom
0.0.2

sort-lines
Tyr
1.9.1

Screenshot of the test explorer right after opening the project folder.

/duplicate https://github.com/microsoft/vscode/issues/150120

Thanks for creating this issue! We figured it's covering the same as another one we already have. Thus, we closed this one as a duplicate. You can search for similar existing issues. See also our issue reporting guidelines.
Happy Coding!

Sorry for the duplicate. I did do an extensive search earlier - but in the wrong repo (I initially thought this was a python thing).
Anyway, after reading the linked issue, I found a workaround that works for all my projects: just enter "." in the test filter, since all my test file names include a ".".


Set the timeout for ActorProxy

Hi everybody,
We have a few issues regarding errors and timeouts when talking to the actors that we are ironing out. The question is if it its possible to tweak the default timeout of 60 seconds on the ActorProxy or otherwise instantialize the class? I guessing there will be very few cases where 60 seconds is needed?
Thanks!
Andreas
RELEASE NOTE: ADD Add DAPR_HTTP_TIMEOUT_SECONDS configuration option.

We can indeed add a timeout value to the public interface.

So we're adding two ways to do this. You can set the environment variable DAPR_HTTP_TIMEOUT_SECONDS
or
proxy = ActorProxyFactory(http_timeout_seconds=10).create('actor_type', 'actor_id')


fixed MS Defender issue on Edge

Fixed issue 26

If this is the issues, I'll take out zooming. Unfortunately, it has to be a hash otherwise it doesn't work in the URL.

I'll remove zoom in the next release.


Added Display claims to where attributes can be used

@bolt-io : Thanks for your contribution! The author(s) have been notified to review your proposed change.

Closing this - the context was for aad technical profiles which do not use display claims


Headless rendering?

Is it possible to use sokol_gfx to render to main memory instead of the screen? If so, any pointers on how to go about it?

closing this...


[Bug] Value transformation n doesn't work

Describe the bug
_n_ transformation works great for Row Name and Col Name, but doesn't work for Value Template
Screenshots

Version Details:

Grafana version : 6.4.0
Plugin version : 1.3.0

Additional context

It does usually work. What does the debug mode says? How your metrics look like?

with debug

@yesoreyeram could you please take a look to debug screenshot?

same issue in v1.3.0

Agree. This is very annoying bug. Tested it with the latest plugin and 3.3, 3.4, 3.5 Grafana's.

Hi,
I downloaded the 1.3 version from https://grafana.com/api/plugins/yesoreyeram-boomtable-panel/versions/1.3.0/download
replacing in the file dist/app/boom/BoomSeries.js the lines:
                BoomSeries.prototype.replaceTokens = function (templateSrv, scopedVars, series) {
                    var _this = this;
                    this.link = this.seriesName.split(this.pattern.delimiter || ".").reduce(function (r, it, i) {
                        return r.replace(new RegExp(_this.row_col_wrapper + i + _this.row_col_wrapper, "g"), it);
                    }, this.link);
                    this.row_name = this.template_row_name.replace(new RegExp("_series_", "g"), this.seriesName.toString());
                    this.col_name = this.template_col_name.replace(new RegExp("_series_", "g"), this.seriesName.toString());
                    this.link = this.link.replace(new RegExp("_series_", "g"), this.seriesName.toString().trim());
                    this.tooltip = this.tooltip.replace(new RegExp("_series_", "g"), this.seriesName.toString().trim());
                    this.display_value = this.template_value.replace(new RegExp("_series_", "g"), this.seriesName.toString());

with
                BoomSeries.prototype.replaceTokens = function (templateSrv, scopedVars, series) {
                    var _this = this;
                    this.link = this.seriesName.split(this.pattern.delimiter || ".").reduce(function (r, it, i) {
                        return r.replace(new RegExp(_this.row_col_wrapper + i + _this.row_col_wrapper, "g"), it);
                    }, this.link);
                    this.display_value = this.seriesName.split(this.pattern.delimiter || ".").reduce(function (r, it, i) {
                        return r.replace(new RegExp(_this.row_col_wrapper + i + _this.row_col_wrapper, "g"), it);
                    }, this.template_value);
                    this.row_name = this.template_row_name.replace(new RegExp("_series_", "g"), this.seriesName.toString());
                    this.col_name = this.template_col_name.replace(new RegExp("_series_", "g"), this.seriesName.toString());
                    this.link = this.link.replace(new RegExp("_series_", "g"), this.seriesName.toString().trim());
                    this.tooltip = this.tooltip.replace(new RegExp("_series_", "g"), this.seriesName.toString().trim());
                    this.display_value = this.display_value.replace(new RegExp("_series_", "g"), this.seriesName.toString());

solved the problem for me. In the current repo state the files are completely different so that I wasn't able to fix that (if it's still a problem) and create a pull request.
I hope this helps. I attached a zipped version of the modified file.
BoomSeries.zip
If it will not work, try modifying the lines in the src/app/boom/BoomSeries.ts file accordingly (I just tested modifying both files, but I'm sure its enough to modify the dist version).

Guys. Sorry bit busy in other day to day stuff. If you can send PR, happy to approve.

I confirm thath fix from @cklos works perfectly.
@cklos your PR may help to other users

I found this  condition. After enabling value override with empty transformation string everything should work fine.
Good luck


Add wget & curl support

At present the code works only with fetch. Allowing for wget or curl should extend this many operating systems.

fixed with commit  3179fb8


Update lemniscap.toml

Description
All previous genesis validators should name their PRs "Update {validator_alias}.toml for tesntet-15" and provide links to previous PRs merged.

https://github.com/anoma/namada-testnets/pull/30
https://github.com/anoma/namada-testnets/pull/138
https://github.com/anoma/namada-testnets/pull/1340
https://github.com/anoma/namada-testnets/pull/2532

If this is an UPDATE for a previous genesis validator
Checks are made against your net_address. If this has changed since the previous testnet, make sure you provide links of previous prs merged from your previous git username.
Thanks in advance!
Checklist before merging

[X] Only one toml is added in this PR
[X] The file being added is indeed a .toml file
[X] The toml being added is to the correct folder, and only to the correct folder
[X] The eth_hot_key and eth_cold_key are present
[X] The email, discord, elements telegram, and twitter fields are present and valid

Successfully validated transactions.toml file for commit hash 8c6afad


Postgres: Simple function doesn't compile anymore (V4.2.1)

I just installed Windows client version 4.2.1 and Postgres 9.6 and dbeaver fails to compile some of my existing functions.
I try with this very simple function:
CREATE OR REPLACE FUNCTION test()
	RETURNS void AS
$BODY$
DECLARE
BEGIN
	IF true THEN
		RETURN;
	END IF;
END;
$BODY$
	LANGUAGE plpgsql VOLATILE;

and it gives the error when compiling : Internal jdbc driver error java.lang.ArrayIndexOutOfBoundsException:

It is a bug in 4.2.1. Will be fixed in the next version, thanks for report.
Workaround: select your functions text and execute as a single statement (CTRL+Enter).


Factor whether statuses are visible into height calculation

If the statuses at the bottom of the screen are not visible at some
point, we should factor that into the calculation of how tall they are.
In order to do that, we now accept a boolean value into topOfStatuses
that denotes whether or not they can be seen.  If this value is false,
we just use the padding value for the height of the statuses.
In order to check whether they are visible, we also need to figure out
whether or not the feedback window is open (they cannot be seen if it is
open).  To do this, we have it export the attribute opened which is
calculated based off of whether its internal panel is open.
Fixes #1334
Pictures from testing below:

LGTM! One open question is whether we should consider the statuses visible if the settings panel is open. My opinion is when the settings panel is open we should also align the toast with the bottom?

I think since we still show the statuses it should be above them?  Definitely something easy to change in the future though.


Create Armstrong_Number.py

Done with Armstrong Number

Great. Could you please add number which is armstrong. In this case it will be not an armstrong for both numbers

can i work on this and add a test case where the number is not an armstrong number??
@jatinkumar027

@ArSin2002 you can work on any other open issue.
@Tejas20-03 Merged successfully


Get collection statistics (PHP 7.3)

Hi,
For statistic / archiving reasons we need to keep track of the total number of documents in several collections.
For now we use the countDocuments() function exposed by the library.
We don't need the $filter nor $options fields. Yet it creates quite a large aggregate pipeline for traversing the collection:
MongoDB\Operation\Aggregate Object
(
    [databaseName:MongoDB\Operation\Aggregate:private] => databaseName
    [collectionName:MongoDB\Operation\Aggregate:private] => collectionName
    [pipeline:MongoDB\Operation\Aggregate:private] => Array
        (
            [0] => Array
                (
                    [$match] => stdClass Object
                        (
                        )

                )

            [1] => Array
                (
                    [$group] => Array
                        (
                            [_id] => 1
                            [n] => Array
                                (
                                    [$sum] => 1
                                )

                        )

                )

        )

    [options:MongoDB\Operation\Aggregate:private] => Array
        (
            [readPreference] => MongoDB\Driver\ReadPreference Object
                (
                    [mode] => primary
                )

            [allowDiskUse] =>
            [useCursor] => 1
        )

)

We have several collections which contain over 20 million documents each. It takes over 30 seconds to run the aggregate above, while running either of these two commands in the MongoDB shell executes within milliseconds:
db.getCollection('collectionName').stats()
db.getCollection('collectionName').find({}).count()
All three commands / queries generate the exact same answer.
Is there a way to achieve either of the latter two calls from PHP without the need of an aggregate?
I'm using version 1.6.0 of the library. Our MongoDB version is 3.4.20
Many thanks in advance!
Matis

The CRUD specification has a section on the Count API. To quote:

The count() helper is deprecated. It has always been implemented using the count command. The behavior of the count command differs depending on the options passed to it and may or may not provide an accurate count. When no query filter is provided the count command provides an estimate using collection metadata.

This is the main reason why there is a countDocuments and estimatedDocumentCount helper. If you want to get a precise number of the documents in a collection, or want to only count some of them, use countDocuments. This will create the aggregation pipeline you saw above and doesn't suffer from the flaws of the count command.
If you want an estimated number of documents and don't need filters, you can use the estimatedDocumentCount helper. This will look at the collection metadata to give you a number of documents, but this number may be off, for example due to orphaned documents or chunk migrations in sharded clusters.


Suggestion on keeping req.param with a better approach

req.param is a very useful utility for us to easily get parameters from many places, thought it would introduce minor problems. But I think it would be better to keep it by solve problems inside express.
the direct using of req.body, req.params, req.query is still very harmful, than using req.param()
which won't change req.body, req.params, req.query's self value.
but if we let the client programmer directly use them, it would lead to a new wrong way .
Here is some code i would like to put as a possible approach.

req.param = function param(name, from) {
  var params = {};
  switch(from) {
    case 'body':
    params = this.body;
    break;
    case 'query':
    params = this.query;
    break;
    default:
    params = this.params;
    if (null != params[name] && params.hasOwnProperty(name)) return params[name];
    return undefined;
  }
  if (null != params[name]) return params[name];
  return undefined;
};

body, query, params can be used in ways like these though maybe by mistakes.
which i don't think would be any good than using req.param() which keep the req content intact.
req.body = null;
req.params = {};
req.query = 'hello';

My two main comments on this are:

This can easily be added as a user-land module, rather than be in core, especially since req.body is not in core, so it would even make sense for a core function to look there.
How would a user be able to access something like req.query.user[1] with that interface?

@dougwilson

although the content of body is not core, but the ability to parse body and to be easily accessed is core to us client programmers. And most of us don't care about the implementation but the ease of using it.

for req.query.user[1], I think it can be retrieved  like this

var user = req.param('user', 'query')[1];
//or
var users = req.param('user', 'query');
var aSpecificUser = users[1];

the structure would be much more clear and if the code is well written, it can also prevent programmers to pollute the data of the incoming request

How will that stop developers from still doing req.param('user', 'query').pop() and altering the user list in the query?

@dougwilson
It could be if function param clone all data out.

Sure. And so, I can see how someone may want to slow down their app by cloning all data over and over again if they want to ensure they don't accidentally change something. Is there a reason this cannot be done as a user-land module? Then people can use this with other frameworks that are Express-like and not only Express.

You could also always add this simple middleware to your app:
app.use(function (req, res, next) {
  // freeze body and query after you populate them
  Object.freeze(req.body || {})
  Object.freeze(req.query || {})
  next()
})

req.param is a lot more complicated, though, because you cannot freeze it up front because then nothing will get populated on it.

maybe it would be good to have a param parser which is configurable and be integrated into param function providing much complicated functions.

Hm, maybe. Can you show what you mean? How would it be different from just doing express.request.param = function(...){} or app.request.param = function(...){} ?

express.request.param can be a standard for derivation or replacement and ease the way the client programmers get data.
and I think express should provide a general but broadly covered one as a base standard. which will better conduct the way the param being parsed.

So there hasn't been any discussion on this is a long while, and I was the only one really participating at the time. If someone feels something along these lines is still desirable, this can always be reopened, I'm just closing this as stale for the time being.

It has been long since the feature request filed:)
And I have created a new framework aex using typescript.
It uses decorators and seems things get much easier and simpler.
The problem can be easily solved by using decorator/injector with (aex)[https://github.com/calidion/aex], without pollute any request don't using params.
But for params's importance to a request, aex make it built-in to request, and can be easily accessed by req.params.
class User {
  @http("post", "/user/:id")
  public async profile(req: any, res: any, scope: any) {
    // req.params.id
    ...
  }
}


Custom Operation for UseDeveloperExceptionPage

Is your feature request related to a problem? Please describe.
I want to log the error to database, for UseExceptionHandler, we could custom it in public static IApplicationBuilder UseExceptionHandler(this IApplicationBuilder app, Action<IApplicationBuilder> configure), but for UseDeveloperExceptionPage, there is no such operation.
Describe the solution you'd like
Provider the Action<IApplicationBuilder> configure in UseDeveloperExceptionPage

Are you trying to log specific errors to the database? If not, why not just write a logging provider (or use one like serilog) that supports logging to the database?
Why do you need a way to hook the developer exception page? That's only used when developing locally (and it also logs the error to the logging system).

Yes, I am trying to log errors to database, and I also want to log the errors while development environment.

@Edward-Zhou Just use a logger provider then.

Using something like this:
https://github.com/serilog/serilog-sinks-mssqlserver

@davidfowl  Is there any specific reason I should not custom it in UseDeveloperExceptionPage middleware like UseExceptionHandler. For logger provider, I will need to implement another middleware with try catch block.

Because there's a better way to solve the problem with a system that was designed to do exactly this (log things). Both the developer exception page and the error handler log the exception.

As @davidfowl said, this middleware isn't designed for this purpose and we don't have plans to add that functionality at this time.


Lapce was terminated when I did try to install a plugin

lapce .

(lapce:87564): GLib-GIO-CRITICAL **: 14:04:32.405: This application can not open files.
host notificaton experimental/serverStatus not handled
host notificaton experimental/serverStatus not handled
[1]    87564 killed     lapce .

lapace --version
lapce nightly-255310e3e062721a5976915f6150a7f28c5c2fe3

I also have this issue. Lapce will not start.
I am running Lapce 0.2.1 if that helps.


NTSD code exec

Pushing module for NTSD (NT Symbolic Debugger) code execution

@hightopfade could you provide some screenshots demonstrating how to use this module? I've tried to execute the module in an Administrative context several times with no success.

working to troubleshoot some issues @xorrior identified when working with Win7 and Win10

Updated the invoke ntsd module
tested working on x86/x86_64 Win7, x86/x86_64 Win 8.1 and x86_64 Win 10
The conflicts are due to spacing issues... tabs v spaces...
Should probably create a "style" guide to ensure that everyone uses the same vimrc for tabs etc etc

@hightopfade I'll take a look and try to get this merged tonight.


need to keep 2.0 and 1.x javascript insync

Now that I've switched to the 2.0 bleeding edge branch, I'd love to see commits like this in 2.0...
https://github.com/twitter/bootstrap/commit/d725ac2feb0abc1469ff526a29de2cf426639ad2

@fat will be addressing this soon I believe. It's an ongoing issue.

The js is just not in a usable state and subject to change dramatically (wip - work in progress). It's ok to play with, but you shouldn't be developing anything serious with it.

I guess I'm confused. The 1.x branch is a work in progress or the 2.x branch is?
It seems all the recent changes are going to 1.x, but I'd expect them to really go to 2.x if it is the 'future'.

If anything, I'd put stuff into 2.x and backport as necessary to 1.x. That'll ease development and keeping things in sync in the future.


JBDS-4249 remove outdated cached dependencies before build

Remove dependency files that are not declared in requirements.json before bundling them, so they don't get used after file name change, etc. Requires #500 to be merged first for the filenames to match requirements.json

Current coverage is 80.16% (diff: 100%)

Merging #502 into master will increase coverage by 0.17%

@@             master       #502   diff @@
==========================================
  Files            25         25
  Lines          2309       2425   +116
  Methods         396        396
  Messages          0          0
  Branches        197        197
==========================================
+ Hits           1847       1944    +97
- Misses          462        481    +19
  Partials          0          0

Powered by Codecov. Last update 4bd20ca...e5ac732


GH-538: Upgrade to log4j2 2.22.1

Thanks - I'll also check if some shaded classes need to be updated.


🐛 Imports are not sorted

VS Code version
1.92.2
Extension version
2.3.0
Biome version
1.8.3
Operating system

[X] Windows
[ ] macOS
[X] Linux

Description
Formatting (on save, or manually) doesn't sort imports.
The extension also doesn't indicate any warning or error regarding import order.
However, biome check reports errors:
biome check main.ts
main.ts organizeImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ✖ Import statements could be sorted:

     1    │ - import·type·{·Construct·}·from·"constructs";
     2    │ - import·{·App,·TerraformStack·}·from·"cdktf";
     3    │ - import·{·AzurermProvider·}·from·"@cdktf/provider-azurerm/lib/provider";
     4    │ - import·{·StorageBackend·}·from·"./src/storage-backend";
     5    │ - import·{·resourceGroup·}·from·"@cdktf/provider-azurerm";
        1 │ + import·{·resourceGroup·}·from·"@cdktf/provider-azurerm";
        2 │ + import·{·AzurermProvider·}·from·"@cdktf/provider-azurerm/lib/provider";
        3 │ + import·{·App,·TerraformStack·}·from·"cdktf";
        4 │ + import·type·{·Construct·}·from·"constructs";
        5 │ + import·{·StorageBackend·}·from·"./src/storage-backend";

Steps to reproduce
Write a TypeScript file with wrongly sorted imports.
Expected behavior
The extension should show a warning or error when the imports are not sorted as expected, and should offer a quickfix.
When formatting the document (manually or on save), the imports should be sorted.
Does this issue occur when using the CLI directly?
No
Link to a minimal reproduction
No response
Logs
No response

Did you follow https://biomejs.dev/analyzer/import-sorting/#import-sorting-via-vscode-extension ?

The extension should show a warning or error when the imports are not sorted as expected, and should offer a quickfix.

This is by design. Import sorting is meant to work very much like formatting: you configure your IDE/editor to run it on save, and then you can use the CLI to enforce it wherever you want

@jackTabsCode me too ……  don't work ~
{
  "editor.codeActionsOnSave": {
    "quickfix.biome": "explicit",
    "source.organizeImports.biome": "explicit"
  },
  "files.associations": {
    "*.css": "tailwindcss"
  },
  "[css]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[javascript]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[javascriptreact]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[json]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[jsonc]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[typescript]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "[typescriptreact]": {
    "editor.defaultFormatter": "biomejs.biome"
  },
  "typescript.tsdk": "node_modules/typescript/lib"
}

After upgrading to 1.9.0
"source.organizeImports": "explicit"

works for me.
"source.organizeImports.biome": "explicit"

does not.
my full codeActionsOnSave now is set to:
"editor.codeActionsOnSave": {
    "source.organizeImports": "explicit",
    "source.organizeImports.biome": "explicit",
    "source.fixAll.biome": "explicit",
    "quickfix.biome": "explicit"
}

as a workaround

This is a regression. It should work with the .biome postfix.


Catch uglifys warning messages

The uglify 'warning' option throws useful messages to console.error. Unfortunately, it does so without filename information. By capturing the console.error call (originating from tool/node.js) and passing the arguments into fancy-log, we fix that.
Note that I'm not thrilled about patching console.error, but feel that actually getting the relevant file name in the output justifies the transgression.
Fixes #163

@terinjokes did you manage to look at this?

I won't be taking this, but I'm open to alternative ideas to #163 in the v3 world.


Searching in a Place's checklist page returns "This list is empty!"

Related to https://github.com/inaturalist/inaturalist/issues/1699

Go to a Place's checklist page (eg https://www.inaturalist.org/check_lists/312-California-Check-List)

Search for anything (eg https://www.inaturalist.org/check_lists/312-California-Check-List?q=lizard)

You get a "This list is empty!" result.

Here's what I get in the console:

https://www.inaturalist.org/check_lists/312-California-Check-List?q=lizard still isn't working


I give error when update new version

What are you trying to achieve?
What do you get instead?

If found error after update new version

Unsupported waitUntil option domcontentloaded,networkidle0

Provide test source code if related

const goToHomePage = () => {
    I.amOnPage(testData.homePageURL)
}

Details

CodeceptJS version: 2.6.0
NodeJS Version: v12.14.1
Operating System: macOS Catalina v10.15.3
Playwright version: 0.12.1
Configuration file:

Playwright: {
            url: `https://${process.env.TEST_ENV}/${process.env.SITE_LANGUAGE}`,
            show: true,
            basicAuth: {
                username: process.env.USERNAME_HOST,
                password: process.env.PASSWORD_HOST,
            },
            waitForNavigation: ['domcontentloaded', 'networkidle0'],
            browser: 'chromium',
            chromium: {
                args: [
                    '--window-size=1366,768',
                    '--no-sandbox',
                    '--disable-dev-shm-usage',
                ],
            },
            windowSize: '1366x768',
            // restart: true,
        },

Have a change something or not? https://github.com/microsoft/playwright/blob/master/docs/api.md#pagewaitfornavigationoptions

@golfzaptw can you try whether the one below works or not?
``Playwright: {
url: https://${process.env.TEST_ENV}/${process.env.SITE_LANGUAGE},
show: true,
basicAuth: {
username: process.env.USERNAME_HOST,
password: process.env.PASSWORD_HOST,
},
waitForNavigation:  'networkidle0',
browser: 'chromium',
chromium: {
args: [
'--window-size=1366,768',
'--no-sandbox',
'--disable-dev-shm-usage',
],
},
windowSize: '1366x768',
// restart: true,
},

@golfzaptw if that works, please close this issue.

It's working, thanks


Never finishes loading world

Something about apotheosis makes it so when I create a new world, it loads to 100% and is stuck at that forever. It does not crash and Minecraft is responsive, it just does not finish loading. It loads when I remove the mod.
Mod List:
AmbientEnvironment-3.0.0.jar
AmbientSounds_v3.0.19_mc1.15.2.jar
BonsaiTrees-<IP_ADDRESS>.jar
Bountiful-3.0.0-1.15.2.jar
classicbar-3.0.2.jar
giantspawn_1.15.2-1.0.2.jar
goblintraders-1.2.0-1.15.2.jar
HunterMod-1.15.2-1.0.3.jar
hunterillager-1.15.2-0.5.0.jar
huskspawn_1.15.2-1.0.jar
immersive-portals-0.8(forMc1.15withForge).jar
Kottle-1.5.0.jar
libnonymous-1.15.2-<IP_ADDRESS>.jar
lycanitesmobs-1.15.2-<IP_ADDRESS>.jar
MixinBootstrap-1.0.2.jar
MutantBeasts-1.15.2-1.0.4.jar
Placebo-1.15.2-3.0.2.jar
reap-1.12.2.jar
repurposedstructures-1.15.2-1.2.1.jar
RiddleChests-<IP_ADDRESS>.jar
ruins-<IP_ADDRESS> (1).jar
skeletonhs_1.15.2-1.1.2.jar
strayspawn_1.15.2-1.0.jar
valhelsia_structures-15.0.2a.jar
zombiehs_1.15.2-2.1.2.jar

You'll have to provide a debug.log file, as I've created quite a few worlds with no issues.

Not sure how to get a debug.log. Hopefully, this is what you need. Only 10% of the time can I start a world and it would work, but when it does not, this is the log:
latest.log

Well, there's two errors in there, one is something else breaking my anvil transforming coremod (couldn't tell you what mod)
And the other is what appears to be a bug in lycanites, but I believe the former is causing the stalling.
Anyway, you'd have to remove mods until you find out what mod is breaking my transformer, and if you do that, tell me, so I can mark said mod as incompatible.


Fundamentals endpoints coming back empty.

Unsure if this is an error on my end or not, but having used both the IBClient and querying the localhost directly I am getting nothing back when using some of the fundamental endpoints, wondering if they maybe have been removed since this code was published?
For example:
https://localhost:5000/v1/api/iserver/fundamentals/{conid}/summary and ib_client.fundamentals_summary both return a summary for a chosen conid as expected.
However:
https://localhost:5000/v1/api/fundamentals/financials/{conid}?type=income&annual=true and ib_client.fundamentals_financials come back as "None" or "Resource not found".
Similarly for ib_client.fundamentals_key_ratios, ib_client.fundamentals_esg, ib_client.fundamentals_dividends, ib_client.data_analyst_forecast, nothing is returned.
I have tried removing and adding the "/iserver/" in the paths to see if maybe it is the wrong path but neither came back with anything. I have tried finding the endpoints by looking at the fundamentals data on my IB account and watching the requests, which are called out to "https://ndcdyn.interactivebrokers.com/tws.proxy/fundamentals/financials/{conid
}?annual=true&type=income" which matches above without the prefix.
Wondering if this is something others have experienced?

I have experienced the same thing. I did not find that the above solution resolved the issue. Any update on this?

So it appears that Interactive Brokers has ended access to the Fundamentals Endpoint using the API; as such, I'll be removing the endpoints from the library. I might try to see if the logic holds with this URL:

https://ndcdyn.interactivebrokers.com/tws.proxy/fundamentals/financials/{conid}?annual=true&type=income

Until then, I'm going to make them "private methods" so people don't get confused. I'm also revamping the process for logging in and will provide an option where you can just let me know if the server is already running or not.

@areed1192 thanks for checking into this! I emailed the IB team about news endpoints that were not on the Restful API documentation, and they said those kinds of endpoints are available through the TWS API, but not yet through the Restful API.
I noticed that you were also using tipranks' api for news. Have you found the quality of their news to be comparable with IB's?


Adding cross partition query implementation

This PR allows the execution of cross partition queries using the CosmosDB REST API, allowing developers using the go SDK to run simple projections and filters, even though more complex queries are restricted by Gateway like TOP, ORDER  BY, OFFSET LIMIT, Aggregates, DISTINCT, and GROUP BY.

@microsoft-github-policy-service agree company="Microsoft"

Thank you @jcocchi and @ealsur for your feedback, I used the workaround and it worked, I'll close the PR then.


Error: Failed with error: Http Error #502 when submitting .zip file

Trying to submit an update using haxelib submit file.zip.
Haxelib client 4.1.0
Output:

Sending data....
File #6093563 accepted : 200630689 bytes written
Processing file....
Error: Failed with error: Http Error #502

I unzipped the file, then rezipped with higher compression, and I was able to submit it.


Ensuring Flash Attention Support in Official Docker Images by Setting Environment Variables

What is the issue?
Does the official Docker image have a runtime environment for Flash Attention? Is it sufficient to directly set the environment variable OLLAMA_FLASH_ATTENTION to configure it?
OS
No response
GPU
No response
CPU
No response
Ollama version
v0.1.39

Yes setting OLLAMA_FLASH_ATTENTION=1 will enable it. Keep in mind only GPUs with compute capability 7+ support flash attention


Implement libslirp for FreeRTOS_Plus_TCP_Echo_Posix demo

Implement libslirp for FreeRTOS_Plus_TCP_Echo_Posix demo
Description

Change network interface implementation from linux to libslirp
Set up local echo server in git workflow and run and test the demo executable
Test Steps

Checklist:

[x] I have tested my changes. No regression in existing tests.
[ ] I have modified and/or added unit-tests to cover the code changes in this Pull Request.

Related Issue

By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.

Thank you for submitting this! I know I posted some naive questions, but I'm not familiar with LibSlirp so I'm kind of hacking together an understanding as I'm reviewing. Thanks in advance for your patience :)

BTW the +TCP Posix Simulator Demo check is failing. Is this expected?


Nvidia Geforce GTX 750Ti
Mod Version
0.6.8.a
Minecraft Version
1.19.2
Loader Version
Forge 43.3.5
Other Mods
idk
Additional Context
idk

Yeah this is a bug with Create DD


Include file where to write generate results in the config?

I think this can be useful, since dirauths assume the measurements will be in a file.
Maybe it is included now and i haven't realized, sorry if that is the case.

It could be done in a more generic way in case we would have some other option that also overrides config.
If you think that's an option, we can close this ticket and create other

I think for now we should just add a path in the example config (which becomes the user's config after running sbws init) and if --output is given when calling sbws generate, it overrides the path in the config.
In the [paths] section in sbws/config.example.ini, I would add an option such as this:
[paths]
v3bw_fname = ${sbws_home}/v3bw

I can do this pretty quickly if you want.

Matt Traudt:

I think for now we should just add a path in the example config (which becomes the user's config after running sbws init) and if --output is given when calling sbws generate, it overrides the path in the config.

Sounds good to me

I can do this pretty quickly if you want.

ok, thanks


How to Set Maximum Water Content?

How do we determine where the maximum water content should be the value for glacier ice (~3%) versus firn (~10%)?
For now I've set the maximum water content based on density:
https://github.com/andrewdnolan/thermal-structure/blob/a4faeddc248bb5c2480d7f7b9309d8f973fc8658/src/elmer_UDF/Thermodynamics.f90#L92-L98
From a prescribed surface density profile if the nodal density rho is less than pore close off rho_f then allow the maximum water content to correspond to firn.
Gwenn made a good point that maybe firn values of maximum water content should be confined to the "firn aquifer". The firn aquifer thickness is a free parameter which we need to set and have been using a reference value of ~3 m for experiments .  So in practice, because of our vertical grid cell spacing, this means only the surface nodes would have firn water content values.
My thought process was given the higher porosity of firn we should allow for more water content. That being said the whole idea of setting firn aquifer thickness is that's the depth over which melt percolates, below which some unmodeled physical processes initiate instantaneous run-off. From the tests I was running with sample data using the firn model, rarely did melt actually reach an impermeable layer (i.e. the ice base) more often in my tests all the melt was consumed to heat the snow pack. I didn't allow for ice lenses  when testing the firn model, but that seems beyond our needed level of complexity.
Not really sure about this one, guess some test to see how important this actually is would be useful.

From a closer rereading of Wilson and Flowers (2013) it appears as though Nat used to the firn aquifer thickness to prescribe the maximum englacial water content. While it's not explicitly stated, the second row of Figure 7. makes it clear that the maximum aquifer water content is coupled to the firn aquifer thickness.

Given that $h_{\rm aq}$ is the denominator
$$
Q_{\rm lat} = (1 - r) \frac{\rho_{\rm w}}{h_{\rm aq} \Delta t} L M ,
$$
but Figure 7. from W&F (2013) show increasingly warmer glaciers with larger firn aquifers; the maximum aquifer water content must be coupled to the thickness.
Given our currently approach, using the pore close off density to set the maximum firn water content, $h_{\rm aq}$ has no physical meaning and actually have an inverse relationship than the W&F (2013). Given that it's in the denominator, the amount of heat added is inversely proportional to $h_{\rm aq}$.
The problem with using the firn aquifer thickness to prescribe the maximum water contents means we need  <1 m vertical mesh resolution at the surface, which we definitely aren't achieving with 15 vertical layers. Looks like in Wilson et al. 2013, Nat used 50 vertical layers. This becomes extra challenging to deal with as we scale up to Kluane glacier which is considerably thicker, so would need even MORE vertical layers.


Adding support for client, lister, informer, deepcopy generation

What type of PR is this?

Uncomment only one  /kind <> line, hit enter to put that in a new line, and remove leading whitespace from that line:
/kind new feature
/kind bug fix
/kind cleanup
/kind revert change
/kind design
/kind documentation
/kind enhancement

/kind enhancement
What this PR does / why we need it:
The PR adds support for client, lister, informer and deepcopy generation for CRDs
Which issue(s) this PR fixes:

Fixes #37
Test Report Added?:

Uncomment only one  /kind <> line, hit enter to put that in a new line, and remove leading whitespace from that line:
/kind TESTED
/kind NOT-TESTED

/kind NOT-TESTED
Test Report:

NA
Special notes for your reviewer:
The generated codes are not added in PR.

@sushanthakumar @PravinRanjan10 @joseph-v
PTAL