error when performing a refresh after a scm_address_object is deleted

Describe the bug
When attempting to refresh after an scm_address_object has been deleted, I receive an error.
│
│ [HTTP 400] API_I00013 Your configuration is not valid. Please review the error message for more details. - map[errorType:Object Not Present message:Failed to find obj-uuid for command
│ get]
╵

Expected behavior
I expect the refresh to detect that the scm_address_object is no longer present and remove it from state.
Current behavior
The refresh returns an error and fails.
Possible solution
I believe this is actually a bug with the API response. It should be responding with a 404 not found but is responding back with a 400 bad request which leads the read to handle the error different that what would be expected as you can see  here.
Steps to reproduce

Run terraform apply

provider "scm" {
  logging = "detailed"
  host = "api.sase.paloaltonetworks.com"
}

terraform {
  required_providers {
    scm = {
      source = "paloaltonetworks/scm"
      version = "0.9.2"
    }
  }
}

resource scm_address_object "example" {
  name = "1-terraform.com"
  folder = "Shared"
  fqdn = "1-terraform.com"
}

Delete scm_address_object outside of TF
Run terraform refresh

Screenshots

Context
This appears to also be the case with most other resources as well.
Your Environment

Version used:
Environment name and version (e.g. Chrome 59, node.js 5.4, python 3.7.3):
Operating System and version (desktop or mobile):
Link to your project:

Same error here with a scm_address_group resource that has been deleted from webUI and Terraform does not detect such event when planning/applying changes:
│ [HTTP 400] API_I00013 Your configuration is not valid. Please review the error message for more details. - map[errorType:Object Not Present message:Failed to find obj-uuid for command get]


Read PDF files from HDFS

Hi @stephenbach @mgoo @SenWu @vincentschen @ZZWENG
I would like read my pdf files from hdfs and convert to html store back in html
So i would like to know how that can be achieved using pdftotree
Appreciate your help as this is something urgent i am looking into

Thanks @HiromuHota
Same applies to fonduer . Can fonduer parse html files in hdfs or we need to have it locally and process
My use case was that i have my pdf files in HDFS and i wanted to first convert them to html and store in HDFS
These HTML files in hdfs are given to fonduer for parsing and generate the data model
Is there any way integrate it with spark so that distributed processing can be used
Appreciate your inputs
@stephenbach @SenWu @mgoo @ashleo25

@ashleo25, please do not tag a list of people for each of your messages. It breaks common GitHub etiquette, since you're tagging people who are not directly involved and generating spam for them.

@lukehsiao Sure i will take care. Sorry for the inconvenience

Same applies to fonduer ?? Can fonduer parse html files in hdfs or we need to have it locally and process

Yes, the same applies to Fonduer. It's currently built to read from your local filesystem and doesn't integrate with Spark or other distributed processes systems at the moment.


[BUG] Scheduled trigger does not run with cron

Mage version
v0.9.73
Describe the bug
When I set up a trigger in a pipeline using scheduling with cron (*/30 * * * *), the trigger is not fired as expected. I'm using the America/Sao_Paulo timezone (UTC-3). It seems that the system is not correctly converting the local timezone to UTC, leading to the trigger failing to execute at the scheduled times. This issue prevents the automated execution of scheduled tasks.

To reproduce
No response
Expected behavior
No response
Screenshots
No response
Operating system
No response
Additional context
No response

@ElcioMFernandes Does the pipeline run as expected if you disable the local timezone setting and create a trigger with the same settings? With a custom trigger that runs every 30 minutes, the local timezone setting shouldn't affect when the pipeline is scheduled to run. Please provide your trigger config if it's saved as code or a screenshot of your trigger's settings to help debug.

Hi Johnson,
I followed your suggestion and disabled the local timezone setting. I created a trigger with the same cron schedule (*/30 * * * *) without the local timezone enabled. Here's a screenshot of the current trigger configuration:

@ElcioMFernandes Is this issue still happening for you? I'm not able to recreate the issue. Trigger seems to be working fine for me with the same settings.


Cant update, "Your requirements could not be resolved to an installable set of packages"

As im a huge linux noob i spent almost an hour just getting to the point of where i could run the update command from the bookstack install folder. When running the command and getting past earlier permission errors, i finally get this error: "Your requirements could not be resolved to an installable set of packages"
I googled it and its probably because of that some of the packages inside the set of programs to be installed have been updated so its dependent on something thats not included or something like that. I hope this can get fixed as i love Bookstack and would like to update it! Still on ver 20 :S

Hi @dewzor,
Do you get any extra output below the "Your requirements could not be resolved to an installable set of packages" message? I'd expect it to list the unresolvable packages. If possible, please post as much of the command line output as possible that you get when running the update command.

Closing since there has been no further followup on this.


Forward compatibility with upcoming Promise v3

Builds on top of https://github.com/reactphp/promise/pull/75, https://github.com/reactphp/promise-timer/pull/55 and https://github.com/reactphp/socket/pull/214
Refs https://github.com/clue/reactphp-http-proxy/pull/44

The first commit updates this to the currently unreleased Socket component to show how this only depends on https://github.com/reactphp/socket/pull/214 (the build should be green). The second commit updates this to the releases that have yet to be tagged. This is expected to fail at the moment and should be green once the releases are tagged and the build is restarted.

Restarted build now that Socket v1.12.0 has been released, this is now ready for review :shipit:
(Unrelated HHVM build error has been fixed via #35 in the meantime)


Issue #62

This should help with issue #62
My pull request will fill varnish.params with proper values based on older sysconfig/varnish file. It's not full problem resolution (still nfiles and memlock will require to overwrite systemd config file) but it's getting closer.
There is also older part that will enable varnishncsa instead varnishlog (I remember it was done in 1.1 version..).

I think I'm fine with merging this, even though we are moving everything to the library methods.  Can you test cent7 with the libraries?  It was working last I checked.

reload of varnish failed for varnish4-ubuntu-1404
883 I, [2015-03-31T11:45:11.409883 #7288]  INFO -- varnish4-ubuntu-1404:     ---- Begin output of /etc/init.d/varnish reload ----
884 I, [2015-03-31T11:45:11.410085 #7288]  INFO -- varnish4-ubuntu-1404:     STDOUT: * Reloading HTTP accelerator varnishd
885 I, [2015-03-31T11:45:11.410315 #7288]  INFO -- varnish4-ubuntu-1404: ...fail!

I will check this tomorrow
wt., 31 mar 2015, 19:29 Matthew Thode użytkownik<EMAIL_ADDRESS>napisał:

reload of varnish failed for varnish4-ubuntu-1404
883 I, [2015-03-31T11:45:11.409883 #7288]  INFO -- varnish4-ubuntu-1404:     ---- Begin output of /etc/init.d/varnish reload ----
884 I, [2015-03-31T11:45:11.410085 #7288]  INFO -- varnish4-ubuntu-1404:     STDOUT: * Reloading HTTP accelerator varnishd
885 I, [2015-03-31T11:45:11.410315 #7288]  INFO -- varnish4-ubuntu-1404: ...fail!
—
Reply to this email directly or view it on GitHub
https://github.com/rackspace-cookbooks/varnish/pull/63#issuecomment-88179324
.

This doesn't look like my fault :-)
It's rather case with Ubuntu's init script or how it's reloading varnish configuration.

Heh, fair enough.  How did using the libraries instead go?  We are likely to move to them (only) fairly soon.

For me libraries are harder to interpret when you're trying to understand cookbooks written by others. Especially when not everything is working as expected.
In case of this cookbook it's working quite well by default and this is enough for me. But it's not working as expected with systemd and in case of logging.
Is there a chance that my pull request will be merged soon?

@gagor Sorry for the delay. The Ubuntu restart issue was resolved today. I'm reviewing this PR and it is duplicating functionality that already exists in the libraries. The libraries already support CentOS 7 and varnishncsa logging.
Another advantage of the libraries are that they are fully tested with both ChefSpec and Serverspec. You can find some examples of using them https://github.com/rackspace-cookbooks/varnish/tree/master/test/fixtures/cookbooks/install_varnish/recipes.
I'm more than happy to discuss on IRC (mattjbarlow on freenode) or through another method. Let me know your thoughts. Also, I'm happy to help with any challenges you face with the libraries.

Hi @mattjbarlow,
I was involved in other projects and didn't have time earlier to review those libraries, today I have it.
First I have to say that I respect your work but I'm sceptical about way these libraries and I will explain in details why:

All these libraries were NOT written to be used multiple times like any other classical LWRP (ex. directory, package). These libraries are just encapsulated recipes.

varnish_install - this library will install package varnish just like package! It's useless for me. If you want to say that it manages repo too this may be done ex. like:

include_recipe "#{coobook_name}::configure_repo_stuff_to_get_out_of_users_eyes"
package 'varnish' do
  version 4.0.3
end

Nothing more is needed.

varnish_default_vcl - this library might be interesting if you add ability to search for backends via roles, etc. But for now it's just template call but written in less readable way.

varnish_default_config - this one was looking promising and usable... but at the end it turned out that it's not. One reason - it doesn't use default attributes set in cookbook, so to use it I have to call it with all parameters (plus probably some conditionals) referencing node attributes.

If you have to go this way you should use these libraries in default recipe and make use of attributes, because for now it's just simpler for me to use older version of cookbook and apply wrappers to get it working like expected.

@gagor, many, many community cookbooks are being rewritten to library cookbooks. It's definitely the trend in the community, as far as I can see from recent releases as well as from the community summits and Chef Conf. Recent rewrite examples include mysql, httpd, database, yum, git. I think the goal with this cookbook is eventually to make it reusable multiple times, like you describe for other resources like package and directory.
My sense of this trend towards libraries is that it's driven because it's much easier to extend small, self-contained building blocks like install/configure/service resources, than it is to adjust attributes to make an upstream recipe behave differently. I feel that it is very difficult to adjust a recipe's behavior if it doesn't provide an attribute, and attributes tend to proliferate and become tricky to maintain when there are sufficiently many of them.

Thanks for response @martinb3. I use those cookbooks but they switched to libraries because of reason. I love how I may easily enable/disable apache modules/vhosts etc. But here you switched to libraries because it's trendy (I'm really sad to tell that).
I think that libraries for managing backends, probes or maybe installing vmods may have sense. Current libs IMHO are just rewritten chef DSL to pure Ruby not because it will be more usable but trendy ;-/
I'm not lib hater - but I just can't see sense for such step in this cookbook.
P.S. Unit testing is not a reason or additional value of lib - I'm testing classic chef DSL without problems :)

But here you switched to libraries because it's trendy (I'm really sad to tell that).

I tried to explain why I think there's a trend towards libraries in my previous comment, and why I think it's a better design in the second paragraph of my comment. We hope to iterate over time to remove some of the pure recipe-DSL and attribute usage in favor of pure ruby. I believe that resources and providers offer more flexibility to the user, and make it easier to maintain the logic.
I think we would be willing to merge PRs that add functionality to the providers and exposes the corresponding resources to the cookbook as a recipe with attributes. I feel like this is a reasonable compromise, as it would allow those who prefer using recipes and attributes to make use of them, and those who prefer declaring resources to make use of those. Would you agree?

There were a number of long standing issues such as lack of ncsa logging support and systemd / centos 7 support. When implementing these fixes, we decided to switch to libraries in order to be more composeable and declarative in end user recipes. Composeable because, with libraries, if you want to install Varnish but not lay down a default template, you can use only the install_varnish resource. Declarative because it is easy to see in your cookbook exactly how resources are configured without having to backtrack through included cookbooks.
Granted there are other ways to accomplish these things. I agree with @martinb3. This PR is for CentOS 7 support, which already exists in the libraries. If we could rewrite the existing recipes to use the working libraries for CentOS 7, and the existing node attributes, would that be acceptable?

I think we should leave topic of libraries - we are free people and we do not have to agree on that :-)
Summing up, if you have working libraries, please use them (like in provided examples). Use current attributes schema (if possible) to configure it and get all benefits of those new libraries. I do not want anything more :-)

I think, since we're moving to LWRPs, we don't need this change anymore. Thank you to all who contributed!


[Bug]: IO::TimeoutError: Failed to open TCP connection to wellbi-india.myshopify.com:443 (Blocking operation timed out!)

### Tasks

Hi @Wellbi-india, it looks like an error with connecting to your store, most likely a transient network issue.
We use the bug issue template to get the information we'll need to help diagnose these kinds of issues, but it seems you used the blank template instead, which means that at the moment we really don't have enough information to investigate.
If you are still experiencing this issue, please file a bug report using the new issue chooser - select bug report and fill in all details.


Local console is disconnected when RDP connection is established in Win 10 Pro 10.0.18362.657

There was already an issue here for older versions, but none of the workarounds seem to work on 1909 and the current termsrv.dll:
https://github.com/stascorp/rdpwrap/issues/422
Is there any other workaround that still works?
My goal is to have an open local session and RDP to the PC from mobile devices using the same user, but not have the local console session being taken over but instead getting a new session for the user when logging in via RDP from the mobile client.  I am using the MS "RD Client" on iOS (there doesn't seem to be any other available and they killed the good old iTag RDP years ago).
The use case is that I want to login remotely with this user and have all the applications and settings of this user available, but at the same time do NOT want to have my windows thrown around in the local session due to the different resolution on the mobile device and use RDP on the mobile device in a resolution that makes sense (and the MS RD Client not even allowing to set the same resolution as I have set locally).
The current behaviour is that when I login via RDP then the local session is taken over and I can login locally to create a new local session.
The desired behaviour is to keep the local session open when logging in via RDP and instead have a new session created for RDP.
See the settings below, the current behaviour is the same no matter what authentication mode I use.

Your settings seem correct
However you can try reset the none single session per user.
First click on Single session per user then Apply. Then uncheck the box and Apply again. See if it works

It`s strange that my Win10 has this same version for termserv.dll but this config screen shows as "not compatible" and it is just like I didnt install anything at all...
I just wanted to two different users use the same computer, one locally and the other remote via RDP

It`s strange that my Win10 has this same version for termserv.dll but this config screen shows as "not compatible" and it is just like I didnt install anything at all...
I just wanted to two different users use the same computer, one locally and the other remote via RDP

Hey, same here. Changing the .ini from #1040 solved the issue for me.

I had similar problem. You can use
rdpwrap.zip
for support RDP on current version Windows.
Step by step:
Run PS from Administrator
Exec "get-service termservice|stop-service -force"
Replace original rdpwrap.ini in C:\Program Files\RDP Wrapper\ on rdpwrap in zip attached.
Exec "get-service termservice|start-service"

Done

It went just fine! Thanks man!

However you can try reset the none single session per user.
First click on Single session per user then Apply. Then uncheck the box and Apply again. See if it works

Same result unfortunately, opening an RDP connection takes over the local console session. Please note that I can have multiple sessions with the same user, however the RDP connection takes over the console session (I can then login from console, to have an additional, parallel session with the same user, but I want the RDP connection to have a separate session instead of taking over the console session).

rdpwrap.ini

file not exists in zip

However you can try reset the none single session per user.
First click on Single session per user then Apply. Then uncheck the box and Apply again. See if it works

Same result unfortunately, opening an RDP connection takes over the local console session. Please note that I can have multiple sessions with the same user, however the RDP connection takes over the console session (I can then login from console, to have an additional, parallel session with the same user, but I want the RDP connection to have a separate session instead of taking over the console session).

this is happening to me too, on Win10 v2004, is there resolution in another issue?

No, that is per design. Logging in remotely will always disconnect the
local session. Without single session, more than one remote connection
could be made under the same user account, and, maybe, the local user could
log back in and get a new session instead of taking over the remote session.
This is a design decision and limitation of windows RDP.
It is recommended that each user that connects remotely have their own user
account. If they need to share some resources, then these can be shared,
say, using the public user's account, or by just giving all the users
access to a shared folder.
On Sat, 4 Jul 2020 at 22:46, evandrix<EMAIL_ADDRESS>wrote:

However you can try reset the none single session per user.
First click on Single session per user then Apply. Then uncheck the box
and Apply again. See if it works
Same result unfortunately, opening an RDP connection takes over the local
console session. Please note that I can have multiple sessions with the
same user, however the RDP connection takes over the console session (I can
then login from console, to have an additional, parallel session with the
same user, but I want the RDP connection to have a separate session instead
of taking over the console session).
this is happening to me too, on Win10 v2004, is there resolution in
another issue?
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/stascorp/rdpwrap/issues/1064#issuecomment-653761820,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AAMCGISNLC5THSE7ELKE4RTRZ4QD5ANCNFSM4MP6RCFQ
.

Yes I have found that RDP remote session will always take over the local console session no matter if you use multi session per user
Best to create another user for remote RDP login purposes

Same as https://github.com/stascorp/rdpwrap/issues/422


Remove preview location.

Thanks for your great work @samtay !
I love this just because its key binding is exactly same as vim, loved it.
Preview location, however, I really don't like it, which causes confusing, also make difference from the classical tetris!
Can we turn on/off the preview location?

Hi @CrazyOptimist yes you can toggle this in the CLI options:
tetris --no-preview

should turn off the preview for you.

Great!
FYI, dex-docker installation raised an error, so I'm using snap installation, also tetris command could not be found, ended up with using this bash alias:
alias tetris="/snap/bin/tetris-thefenriswolf.tetris $1"
Thank you 👍

Oh man, dex is probably bit rotten by now 😆 I'll remove that from the README. Thanks for the tip on the alias as well.


[FEAUTURE] EC2: Implement way to select which tags to show on table output

Implement a way to select which tags to show on table output.
I don't know yet if should create a new flag for it or figure out a way to use --show-tags for it.
The challenge to use --show-tags for it is to check if it isn't present, if it is empty or it has a list.

I think it could be implemented using a flag, with a slice of tags to hide/show and use IsStringInSlice when printing


Edit mode only suspends app useFrame/useUpdate calls

Edit mode is meant to have the app without any loops executing so that objects can be interacted with. The current implementation of this replaces useFrame and useUpdate with an editor version that lets us suspend the callback, but only for calls that originate in the user app -- not from libraries. Consequently, any library interaction or even pointer events from R3F still occur in edit mode.
This can be seen in the ClickAndHover R3F example.
Proposed solution
Instead, I think we should suspend the R3F loop by setting it to never and then running our own loop for rendering while in edit mode. When we exit edit mode, we suspend our loop and let the app execute as it normally would. The API for doing this would be the same between v8 and v9 but v9 would allow more options, for example suspending only certain stages for the purpose of debug.

So setting the top level Canvas used during edit mode to frameloop="never" and then implementing an alternate useFrame  that would run during edit for some things? What about use cases such as wanting to preview an animation, or working on a shader where you'd want some code executing every frame so you can effectively work on it without needing to jump into play mode, it'd be a bit more nuanced as to what the best solution is. Third party modules make it harder but we can always transform that code as well so I wouldn't say it's off the table.

Maybe it'll help to do a breakdown of the bigger idea. I am modeling how I approach the editing system off of the Unreal and Unity editor, but mostly Unreal. There are three distinct actions that are used to control the editor states: play, stop and pause. The editor begins as if stopped so I'll start there.

Stop: When stopped, the editor is in a typical edit mode. The app has no systems running at all. It is as if it is completely static and never initialized. This is where you fly around and place the static or start state of objects, volumes, triggers, lights, etc. We run our own editor loop for rendering and anything that needs to be active while editing goes into this loop too such as any camera controls.
Play: The app starts running, We let the R3F loop do its thing and pause the editor loop. Here you can test whatever you want in the game. Doing a stop action from here will reset back to the initial app state and clear any effect of the app logic running.
Pause: When the pause action occurs, we suspend the R3F loop and go back to the edit mode, but the app state is not reset. This way you can play, pause, then edit based on what the app state reveals. Resuming keeps running the R3F loop with whatever changes HMRed in code.

And then I am experimenting with modifying R3F core to allow for frame stepping. That is you pause the app and then choose a delta to advance by allowing for fine grained analysis as you edit.
Anyway, the way I see it no app systems should ever run while we are editing. They can only interfere and have unintended side effects that would not appear in production. To do this, my strategy is to suspend the R3F loop and put back just enough into an editor loop for whatever editing tasks we need. This isn't so bad because in R3F v9 the Stage class is a module and I might do the same with the whole scheduler so it can be easily reused inside the editor.

The more I thought about this, the more I am assured it is a good idea to use our own loop and not just be a root inside of R3F's. The main reason is the clock.
The R3F app's time should be completely independent from the editor. For example, if the position of an object is depended on clock.elapsedTime (usually with Math.sin), when you play and pause the app, it will work as expected with the animation continuing from where it left off. If instead the editor and app shared a clock then the animation would jump forward in time as soon as play was resumed since time kept ticking during edit mode.
The main con here is that we would need to implement the event manager on the editor side too since it relies on the R3F loop to execute. But this is fine. If we want some kind of "live edit mode" where the app logic runs AND the editor logic runs at the same time we will run into a (solvable) problem but I honestly don't think it's a good idea anyway considering the number of uncontrollable side effects that could occur.

Great insight thanks Krispy. Definitely resonates with me! What's needed for step in r3f core, vs implementing ontop of frameloop demand? I implemented my own in user land that would take control of use frame, probably similar to the current implementation after hearing about it. I do remember that demand has a bug where the clock keeps ticking.

To be honest, I haven't tried demand. The way R3F v8 is right now, it should work just as well since invalidate steps one frame at a time, but I have some conceptual concerns. (The clock is something I'll fix in general as it is completely busted if it doesn't just constantly run. )
The difference between never and demand is a conceptual one that needs to be worked out on the R3F side. never was originally intended for testing where you advance by a target amount of time (though the current implementation isn't that useful IMO), while demand was intended for on-demand rendering, so you only render frames when you need them but otherwise the app logic keeps ticking. I want to harden these concepts in core, but to me what they mean is that never should enforce no app logic process until advance is called and then simulates advancing by the target delta time while demand keeps ticking but rendering is paused until invalidate is called.
If others agree with these concepts then I would want to use never for editor purposes as demand could conceptually allow leaking.
Also, I am realizing that the createRoot system might do what I want. It generates a new clock for each root, I believe originally intended for managing multiple canvas in one app. It might actually make sense to take advantage of this and have an editor root that actually just operates on the main root's scene.

Conceptually I understand what we're planning on doing, but when we consider an implementation I need some help getting there. Is this understanding correct? If not let me know the specifics I'm missing:

We have a canvas that overrides the r3f export, so in user land when they import it they get this override instead of the original one
This canvas would have two roots, one for play/pause, one for edit
Each root owns its own clock to prevent unexpected jumps between frames
Switching between modes would result in unmounting children from one canvas and placing it in the other

As a side do we have a concept of opening individual scenes (components)? Or it's just whatever the userland is rendering beneath their Canvas atm?

Conceptually I understand what we're planning on doing, but when we consider an implementation I need some help getting there. Is this understanding correct? If not let me know the specifics I'm missing:

We have a canvas that overrides the r3f export, so in user land when they import it they get this override instead of the original one
This canvas would have two roots, one for play/pause, one for edit
Each root owns its own clock to prevent unexpected jumps between frames
Switching between modes would result in unmounting children from one canvas and placing it in the other

As a side do we have a concept of opening individual scenes (components)? Or it's just whatever the userland is rendering beneath their Canvas atm?

When Nikhil gets done with the refactor I can push what I got started to build off of.
And the idea I had for the root was that there would be only one canvas but that the editor root would be "headless" and work off the scene being edited. If that kind of setup works is what needs to be tested.

When Nikhil gets done with the refactor I can push what I got started to build off of.
And the idea I had for the root was that there would be only one canvas but that the editor root would be "headless" and work off the scene being edited. If that kind of setup works is what needs to be tested.

Yeah I would like to be able to not remount everything when going from edit to play mode (okay when coming back).. remounting is always slightly slow and if we can avoid it we should.

Okay here is a proof of concept: https://codesandbox.io/p/sandbox/react-three-editor-root-test-iqyx9m?file=%2Fsrc%2Ffeatures%2Feditor%2Feditor.tsx
I hacked around adding a headless root with custom provider. Any R3F hook called inside the EditorProvider will use the editor root and any called in the usual app Canvas will get their original root. You can suspend and modify the loops independently but they share the same rAF and EventManager.
This needs a clean up, but it proves the idea!

Interesting! So to summarize what's happening:

Using the context export from r3f we can override the store that is provided to child r3f hooks.
App world component "resets" the provider back to the original store
Editor world calling state.gl.render(state.scene, state.camera); takes over rendering (why?)
_roots hold r3f roots (a root is just threejs instances and config from the looks of it? Is this public API? Do we need to redeclare everything?)
To enable play -> pause -> edit flows it's just a matter of conditionally setting the editor provider + taking over the render loop when appropriate, or is there more involved?

Yeah! I'm digging into some of these internal more myself. Cody is the real genius behind the reconciler and root system.
No you got it. I'll break it down as I realized even my example has an issue that can be worked out better.
R3F uses a concept roots to define independent instances of renderers that are managed by the same R3F instance. So typically this is for each Canvas is defined, so no matter how many Canvas you create, they share the same rAF loop, event manager, etc.
Roots were not intended to be a public API but _roots is being exported for historical reasons and I am taking advantage of this fact to do a little manipulation. I am creating a custom root for the editor that shares the same scene and gl renderer as the app which makes it so that the editor loop and app loop are now independent. We can start and stop them without effecting one another and their keep their own time, callback subscribers, events, etc.
To take full advantage of this I then do what you say, I override the Canvas component in the app with ours where we inject the editor components which looks like this:
<OverrideCanvas>
  <DomComponents />
 <DomSystems />
  <Canvas>
    <EditorProvider>
      <FiberComponents />
      <FiberSystems />
      <AppProvider>
         <App />
       </AppProvider>
    </EditorProvider>
  </Canvas>
</OverrideCanvas>

And this way any R3F hook calls inside of EditorProvider use the editor store and any inside AppProvider use the app store not knowing at all that its environment was tampered with.
The issue I was having was that I was trying to create the editor root before the app root, even though the editor root needs to use the app root's scene and gl renderer. I was being foolish and didn't realize that actually the app root gets created first anyway and I don't need to portal it from inside App upward -- it gets created as soon as Canvas is mounted.

Oh and to answer some other questions. advance is not used in useFrame and could be defined in the store. It just happens to be defined in the loop file which is why it gets imported. It probably doesn't need to be written that way. And we need to take over rendering on the editor loop because we pause the app loop so if we want to display objects being moved around, we need renderer draw calls to come from the editor.

Thanks Krispy it's all becoming clearer now! I really like this direction. I see the value in getting this thought through, similar to other core functionality (code/scene sync, editor/scene state). Get them right and it's a breeze building on top.
Love it

Here is the branch implementing this strategy: https://github.com/pmndrs/react-three-editor/pull/36
So far it's working pretty well, but I'll need to dig deeper for events and also some of the tunneling.
advance is used when the frameloop is set to 'never'. It takes a timestamp and advances (heh) the frozen loop by the delta with the previous advance call. IMO it makes more sense for you to pass in a delta and advance by an exact amount, but that's a discussion for v9.
As for _roots, I do think for v9 we will want to make a public API. Part of what I want to do with this editor is see if there is a legitimate use case for a "headless" root and if there is, then look at creating a public API for it. There is a createRoot function already but it requires a canvas element currently.

Okay! The implementation is now nearly complete with events working. I'll share what I learned about events so we can work on the details together. I had assumed that initializing a root store got you all you needed for an event manager, but this is not true. In fact, because R3F supports native and web, the events manager is initialized separately and passed into the store. This is what the events export is. For web, it is createPointerEvents aliased to a really poorly named export because I thought it was an object but turns out it is actually a factory. Other than that, there were a few other properties I needed to copy over into my headless root from the app root such as size and viewport and then things were good to go.

Events should finally be working with https://github.com/pmndrs/react-three-editor/pull/39


Comparisons of N-MOS and S-MOS: this vs QuickVC

I wonder if you have already have data on this?

Sorry, I don't compare them because they use different datasets and face different tasks. What I'm sure is ConsistencyXVC is better than QuickVC in terms of cross-lingual voice conversion, and ConsistencyEVC is better in terms of expressive voice conversion.


Upgrade embedded Python

The embedded Python is still 2.7, and that is rapidly approaching EOL on January 1, 2020. We just ran into an issue today where one of our checks was written assuming Python 3.6 (since that's what the rest of our codebase uses), and then it crashed and burned because the embedded Python is so old.
It would be great if there was a way to point to a different Python interpreter or things were just upgraded.

Hi @dan-blanchard, thanks for the concern. We have plans to upgrade the embedded Python v2.7 to v3 before 2.7's EOL, but no timeline that we can share at this point. We'll update the issue when we have more info to share, thanks!

Just hit this again. It's really frustrating that we're forced to litter our codebase with compatibility hacks to work with legacy Python.

Python 2.7 EOL is less than 9 months away. Can you offer any updates on the timeline here?

4 months and 22 days left until Python 2.7 EOL. Any updates?

Hi @dan-blanchard 👋
We had followed up earlier via email about this back in August, but also reaching out here. Datadog Agent v6.14.0 introduces the ability to run the Python 3 runtime instead of Python 2. You can find more information about how to enable this mode, as well as tips on migrating any custom checks to Python 3 on our docs page here.
If you run into any issues, please reach out to<EMAIL_ADDRESS>and we'll be happy to help out. Thank you!

Closing out this issue, now that Datadog Agent 6.14+ includes the option of enabling the Python 3 runtime.


Modules suggestion

https://www.criminalip.io/ - Criminal IP is a specialized Cyber Threat Intelligence (CTI) search engine that allows users to search for various security-related information such as malicious IP addresses, domains, banners, etc. It can be widely integrated

Thanks for the suggestion.
Will take a look on the API documentation and consider adding it in future "release"

Thanks, Bro


Database does not exist

Describe the bug
I'm trying to start a new container because it seemed like something got messed up, but it says the database does not exist.
Environment Details (please complete the following information):

OS: Mac OS Sonoma 14.5
Browser: Opera
Jellystat Version: 1.1.0
Jellyfin Version: 10.9.11

To Reproduce
Steps to reproduce the behavior:

Delete "jellystat" folder
Try to run jellystat docker-compose.yml file.
See error (explained below)

docker-compose.yml
jellystat-db:
    image: postgres:15.2
    container_name: jellystat_db
    environment:
      POSTGRES_DB: 'jfstat'
      POSTGRES_USER: nothing2obvi
      POSTGRES_PASSWORD: 'xxx'
    volumes:
      - /Users/username/Docker/jellystat/postgres-data:/var/lib/postgresql/data # Mounting the volume
    ports:
      - 5432:5432
    restart: unless-stopped
  jellystat:
    image: cyfershepard/jellystat:1.1.0
    container_name: jellystat
    environment:
      POSTGRES_USER: nothing2obvi
      POSTGRES_PASSWORD: 'xxx'
      POSTGRES_IP: jellystat-db
      POSTGRES_PORT: 5432
      JWT_SECRET: 'yyy'
    ports:
      - "3000:3000" #Server Port
    volumes:
      - /Users/username/Docker/jellystat/backup-data:/app/backend/backup-data # Mounting the volume
    depends_on:
      - jellystat-db
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    restart: unless-stopped

Error in Logs: See below, under "Container Logs."
Expected behavior
Jellystat should start up fine with no errors with the database.
Container Logs
jellystat
all values are hidden
><EMAIL_ADDRESS>start
> cd backend && node server.js
all values are hidden
error: database "sirnothing" does not exist
    at Parser.parseErrorMessage (/app/node_modules/pg-protocol/dist/parser.js:287:98)
    at Parser.handlePacket (/app/node_modules/pg-protocol/dist/parser.js:126:29)
    at Parser.parse (/app/node_modules/pg-protocol/dist/parser.js:39:38)
    at Socket.<anonymous> (/app/node_modules/pg-protocol/dist/index.js:11:42)
    at Socket.emit (node:events:520:28)
    at addChunk (node:internal/streams/readable:559:12)
    at readableAddChunkPushByteMode (node:internal/streams/readable:510:3)
    at Readable.push (node:internal/streams/readable:390:5)
    at TCP.onStreamRead (node:internal/stream_base_commons:191:23)
[JELLYSTAT] Database exists. Skipping creation
FS-related option specified for migration configuration. This resets migrationSource to default FsMigrations
FS-related option specified for migration configuration. This resets migrationSource to default FsMigrations
[JELLYSTAT] Server listening on http://<IP_ADDRESS>:3000

jellystat_db
The files belonging to this database system will be owned by user "postgres".
This user must also own the server process.
all values are hidden
The database cluster will be initialized with locale "en_US.utf8".
The default database encoding has accordingly been set to "UTF8".
The default text search configuration will be set to "english".
all values are hidden
Data page checksums are disabled.
all values are hidden
fixing permissions on existing directory /var/lib/postgresql/data ... ok
creating subdirectories ... ok
selecting dynamic shared memory implementation ... posix
selecting default max_connections ... 100
selecting default shared_buffers ... 128MB
selecting default time zone ... Etc/UTC
creating configuration files ... ok
running bootstrap script ... ok
performing post-bootstrap initialization ... ok
syncing data to disk ... ok
all values are hidden
all values are hidden
Success. You can now start the database server using:
all values are hidden
    pg_ctl -D /var/lib/postgresql/data -l logfile start
all values are hidden
initdb: warning: enabling "trust" authentication for local connections
initdb: hint: You can change this by editing pg_hba.conf or using the option -A, or --auth-local and --auth-host, the next time you run initdb.
waiting for server to start....2024-09-29 20:01:48.479 UTC [49] LOG:  starting PostgreSQL 15.2 (Debian 15.2-1.pgdg110+1) on aarch64-unknown-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
2024-09-29 20:01:48.485 UTC [49] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
2024-09-29 20:01:48.491 UTC [52] LOG:  database system was shut down at 2024-09-29 20:01:47 UTC
2024-09-29 20:01:48.497 UTC [49] LOG:  database system is ready to accept connections
 done
server started
CREATE DATABASE
all values are hidden
all values are hidden
/usr/local/bin/docker-entrypoint.sh: ignoring /docker-entrypoint-initdb.d/*
all values are hidden
waiting for server to shut down....2024-09-29 20:01:50.234 UTC [49] LOG:  received fast shutdown request
2024-09-29 20:01:50.235 UTC [49] LOG:  aborting any active transactions
2024-09-29 20:01:50.282 UTC [49] LOG:  background worker "logical replication launcher" (PID 55) exited with exit code 1
2024-09-29 20:01:50.283 UTC [50] LOG:  shutting down
2024-09-29 20:01:50.284 UTC [50] LOG:  checkpoint starting: shutdown immediate
2024-09-29 20:01:50.899 UTC [50] LOG:  checkpoint complete: wrote 918 buffers (5.6%); 0 WAL file(s) added, 0 removed, 0 recycled; write=0.205 s, sync=0.404 s, total=0.616 s; sync files=250, longest=0.076 s, average=0.002 s; distance=4217 kB, estimate=4217 kB
2024-09-29 20:01:50.989 UTC [49] LOG:  database system is shut down
 done
server stopped
all values are hidden
PostgreSQL init process complete; ready for start up.
all values are hidden
2024-09-29 20:01:51.187 UTC [1] LOG:  starting PostgreSQL 15.2 (Debian 15.2-1.pgdg110+1) on aarch64-unknown-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
2024-09-29 20:01:51.188 UTC [1] LOG:  listening on IPv4 address "<IP_ADDRESS>", port 5432
2024-09-29 20:01:51.188 UTC [1] LOG:  listening on IPv6 address "::", port 5432
2024-09-29 20:01:51.192 UTC [1] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
2024-09-29 20:01:51.198 UTC [65] LOG:  database system was shut down at 2024-09-29 20:01:50 UTC
2024-09-29 20:01:51.281 UTC [1] LOG:  database system is ready to accept connections
2024-09-29 20:01:53.480 UTC [69] FATAL:  database "nothing2obvi" does not exist
2024-09-29 20:06:51.300 UTC [63] LOG:  checkpoint starting: time
2024-09-29 20:07:14.623 UTC [63] LOG:  checkpoint complete: wrote 229 buffers (1.4%); 0 WAL file(s) added, 0 removed, 0 recycled; write=23.304 s, sync=0.011 s, total=23.325 s; sync files=82, longest=0.002 s, average=0.001 s; distance=1299 kB, estimate=1299 kB

Additional context
Add any other context about the problem here.

Hey @nothing2obvi , try setting POSTGRES_DB under jellystat aswell to match the POSTGRES_DB  value under postgres

Sorry for the late follow-up, but it looks like I didn't do that it and it just works again.


Adds windoze compatibility

https://github.com/roots/sage/issues/1351

Coverage remained the same at 100.0% when pulling 9292b5d38e42baf9d6934d6281db3b890344d70c on windoze into 65b4909405407543ba90a7c22d540f786be364bc on master.

Coverage remained the same at 100.0% when pulling 9292b5d38e42baf9d6934d6281db3b890344d70c on windoze into 65b4909405407543ba90a7c22d540f786be364bc on master.

thanks @coveralls

Coverage remained the same at 100.0% when pulling ade114813016239bbe78063696db9167ef4a6732 on windoze into 65b4909405407543ba90a7c22d540f786be364bc on master.

Coverage remained the same at 100.0% when pulling 6aba86dac2a9202794cc134b095eef0e24a03262 on windoze into 65b4909405407543ba90a7c22d540f786be364bc on master.

@coveralls can we get another update on the coverage? I would like to know if it has changed within the last 8 minutes.

I would like to thank @coveralls and Obama for this patch

lol u guyz

Obama needs a github profile


How We Work spot illustration

It doesn't show up currently. Make it match the design.
Illustration here: https://drive.google.com/file/d/1FM-fhGAJeiKHRAVIWF_Fuc-WdtWYpRbh/view?usp=sharing

sorted here https://github.com/Fireflower2012/CooperationHullMainSite/pull/139


Use line coverage, fix, guide

Description
Use line coverage, instead of function coverage.
Fix html report (was after exit)
Add guide to create local report.
Testing instructions

Types of changes

Checklist

[x] Prefix PR title with [WIP] if necessary.
[x] Add tests to cover changes as needed.
[x] Update documentation as needed.
[x] I have read the guidelines for adding a new blockchain
[x] If there is a related Issue, mention it in the description (e.g. Fixes #<issue_number> ).


Background image shown in canvas but not in image output

Hi,
I can easily add background image to the canvas but am not able to get it in the image output. Is there anything I need to look at?
I added background image using 'drawImage'.

I had issues loading images, so I decided to use a Promise to ensure the image was loaded:
`async function loadImage(url) {
let img = new Image();
await new Promise((r) => (img.onload = r), (img.src = url));
return img;
}
const encode = (img) => {
encoder.start();
context.drawImage(img, 0, 0, canvas.width, canvas.height);
encoder.addFrame(context);
encoder.finish();
document.getElementById("image").src =
"data:image/gif;base64," + encode64(encoder.stream().getData());
};
loadImage("280px-PNG_transparency_demonstration_1.png").then(encode);`


tiff file bands name missing

(1) In R
In R package terra, I can get the band names. But it failed in Julia.
library(terra)
#> terra 1.5.21
r = rast("H:/global_WB/ET/diagnosed_PML/PMLV2_v016/PMLV2_yearly_G010_v014_2017-01-01.tif")
r
#> class       : SpatRaster
#> dimensions  : 1500, 3600, 7  (nrow, ncol, nlyr)
#> resolution  : 0.1, 0.1  (x, y)
#> extent      : -180, 180, -60, 90  (xmin, xmax, ymin, ymax)
#> coord. ref. : lon/lat WGS 84 (EPSG:4326)
#> source      : PMLV2_yearly_G010_v014_2017-01-01.tif
#> names       : GPP, Ec, Es, Ei, ET_water, ET, ...
names(r)
#> [1] "GPP"           "Ec"            "Es"            "Ei"
#> [5] "ET_water"      "ET"            "days_coverage"

Created on 2022-03-26 by the reprex package (v2.0.1)
(2) In Julia
using Rasters
f = "/mnt/h/global_WB/ET/diagnosed_PML/PMLV2_v016/PMLV2_yearly_G010_v014_2017-01-01.tif"
RasterStack(f)

RasterStack with dimensions:
  X Projected range(-180.0, stop=179.9, length=3600) ForwardOrdered Regular Intervals crs: WellKnownText,
  Y Projected range(89.9, stop=-60.0, length=1500) ReverseOrdered Regular Intervals crs: WellKnownText,
  Band Categorical 1:7 ForwardOrdered
and 1 layer:
  :layer1 Float64 dims: X, Y, Band (3600×1500×7)

with metadata Metadata{Rasters.GDALfile} of Dict{Symbol, Any} with 3 entries:
  :offset   => 0.0
  :scale    => 1.0
  :filepath => "/mnt/h/global_WB/ET/diagnosed_PML/PMLV2_v016/PMLV2_yearly_G010_v014_2017-01-01.tif"

The tiff file at here

This is my solution for tiff bandnames https://github.com/jl-spatial/Stars.jl/blob/master/src/gdal_basic.jl#L46.
Hope that helps.

Thanks


refac(ci): Trigger fullstack-compat-test on travis

Summary

Runs the fullstack compat suite tests on Travis CI
Accompanying PR: https://github.com/optimizely/fullstack-sdk-compatibility-suite/pull/158

Pull Request Test Coverage Report for Build 796

0 of 0   changed or added relevant lines in 0 files are covered.
No unchanged relevant lines lost coverage.
Overall coverage remained the same at 89.77%

Totals

Change from base Build 788:
0.0%

Covered Lines:
2694

Relevant Lines:
3001

💛  - Coveralls


[Enhancement] My tablet is not compatible T.T

(i tried using the latest artifact)
Is your feature request related to a problem? Please describe.
PlayStore tells me that is not available for my device and if i download the apk it tells me something like "it look like the package is not valid"
Describe the solution you'd like
Make it compatible with my tablet please.
Additional context
Device: Lenovo Smart Tab M10 HD Wifi
Arq: ARMv8-A 64bits
OS: Android 10

Android 11 is the minimum version required

Can i ask why Android 11?

I'll create a tab in README because this question is already way too asked and answered.
Android 11 is the minimum android version required to keep all features of the Gallery like Trash-bin, most of the API used etc.
Reducing the android version would result in feature loss for under android 11 devices and would require lots of compatibility changes for the MediaStore API

This question must be very frequent because, in my opinion, Android 11 is a very high version for the minimum requirement of an app that is so necessary for everyday use. My phone has Android 13 thanks to a custom ROM, otherwise it would still be on Android 10 and usually, the devices of people I know have Android 9/10.
I feel sad that such a good app didn't get more reach because of this compatibility detail.


Using map_blocks/map_overlap on two arrays

In some cases one needs to be able to use map_blocks/map_overlap or similar on two large arrays (i.e. Dask Arrays). Some examples include convolutions/correlations and some morphological operations (e.g. see binary_dilation's structure and mask parameters). It would be nice if there were some API function(s) to help with this case.

Can you explain how the current interface is insufficient? Both the map_blocks function and method take multiple arrays.
For multi-array map_overlap, support could be added.

Sorry. Some of the lines in the docs lead me to believe map_blocks did not support this (e.g. "Map a function across all blocks of a dask array."). Though the examples do paint a different picture. Would still like to see this for map_overlap as handling extended borders is quite common.
FWICT from the examples it seems that map_blocks just takes the corresponding regions in each array and operates on them. Once halos/ghosting is addressed, this would solve the issues involving morphological operations noted above
However in the case of things like convolve, a bit more is needed. First one would need to take all permutations of all ghosted chunks from both arrays, compute their results, and then reduce them. Thinking on this, using the term map here was confusing. Perhaps product or permute or similar would be more appropriate.

I'd love to help write a multi-array map_overlap method.  I've just hit my second need for it. Is anyone aware of work towards this already?

There are gufuncs, which sort of do this today. There are no other efforts to my knowledge.

I haven't used gufuncs, but it looks like the map_overlap interface would be somewhat simpler interface for common use cases.  And map_overlap is just calling map_blocks under the hood, so it looks like a fairly straightforward thing to implement.   I could imagine I'm missing some checks that need to be done.   Deciding the function signature is probably a bit tricky.
Here's something I've tried using.
import dask.array as da
from dask.array import Array
from dask.array.overlap import coerce_depth, coerce_boundary, overlap, trim_internal

def map_overlap_multi(func, *args, depth, boundary=None, trim=True, **kwargs):
    arrs = [a for a in args if isinstance(a, Array)]

    overlap_arrs = []

    for arr_index, arr in enumerate(arrs):
        depth2 = coerce_depth(arr.ndim, depth)
        boundary2 = coerce_boundary(arr.ndim, boundary)

        for i in range(arr.ndim):
            if isinstance(depth2[i], tuple) and boundary2[i] != "none":
                raise NotImplementedError(
                    "Asymmetric overlap is currently only implemented "
                    "for boundary='none', however boundary of array #{} for dimension "
                    "{} is {}".format(arr_index, i, boundary2[i])
                )

        assert all(type(c) is int for cc in arr.chunks for c in cc)
        g = overlap(arr, depth=depth2, boundary=boundary2)
        assert all(type(c) is int for cc in g.chunks for c in cc)
        overlap_arrs.append(g)

    g2 = da.map_blocks(func, *overlap_arrs, **kwargs)
    assert all(type(c) is int for cc in g2.chunks for c in cc)
    if trim:
        return trim_internal(g2, depth2, boundary2)
    else:
        return g2

Hey @chrisroat did that end up working well for you?  I keep bumping into use cases for this as well.
I'd be happy to work a PR for it.

In general I agree that map_overlap could probably be made to be multi-array friendly by ...

Rechunking everything to a common chunking
Doing the overap stuff on all of the arrays
Calling map_blocks
Calling trim on all of the arrays

We'll need to do boundary filling and trimming in a consistent way of course, but hopefully that's somewhat straightforward.
Ideally this is added to the existing map_overlap function so that it is made more general, rather than making a new function and expanding the API.  The dask.array.overlap.map_overlap function seems to be relatively straightforward, and hopefully has the necessary pattern to follow.
A PR would be welcome.

I have a variation on this that I use regularly, but it's specific.  I got a bit gun-shy of dealing with the depth question in a general way.  I only needed overlaps in one array, and had just one auxiliary array, so made.  I put it in this gist, along with a blockwise-overlap variation.
https://gist.github.com/chrisroat/07714f2fd3a4f49cc832e8f8ab868a79
I think I would throw an error if the arrays have dissimilar chunking, rather than try to figure out what the common chunking would be.  Or have a way to turn off the checking, like the align_arrays parameter in blockwise.  In my case, my arrays different numbers and sizes of dimensions.
The tricky part is dealing with how to represent depth and boundary.   They already have a lot of different representations (number, tuple, dict), and now there needs to be yet another layer, to handle with it being different for each array.

FWIW it's probably sufficient these days to just solve the map_blocks problem. With tools like da.pad users should be able to pad before going into map_blocks and slice off the overhang afterwards. Admittedly that is 3 lines instead of 1, but that is probably reasonable as we consider making map_blocks more flexible.

I think we've converged on the thought that map_blocks already does handle the multi-array case.
I do not understand the da.pad statement.  Are you suggesting people do the work of map_overlap in their own code.  That's effectively what I had to do in map_overlap_multi in my gist linked above.  It's not pad/trim, but da.overlap.overlap/da.overlap.trim_internal -- every chunk needs to be padded and trimmed.
The map_overlap method also handles the coercion of depth/boundary into the forms that da.overlap.overlap uses.

Thanks for the updates @chrisroat!  Very helpful.
@mrocklin how do you feel about enforcing a common chunking rather than trying to rechunk to one?  I'm trying to think about how that could work but it seems dangerous to have to pick between increasing or decreasing chunk sizes of certain arrays transparently.  At least in my case, I definitely wouldn't want that -- I'd rather have to think about which arrays represent the best structure given what I know the function will be doing.  Or is this something other functions somewhere in the array API already do?
I am going to take a crack at a PR that builds off of what Chris did so any further guidance/suggestions would be awesome.

I think that fundamentally you're looking for dask.array.core.unify_chunks.  It may also be that the broadcast_arrays function does what you want more simply.
In [1]: import dask.array as da

In [2]: x = da.ones(10, chunks=(4,))

In [3]: y = da.ones(10, chunks=(5,))

In [4]: da.broadcast_arrays(x, y)
Out[4]:
[dask.array<rechunk-merge, shape=(10,), dtype=float64, chunksize=(4,), chunktype=numpy.ndarray>,
 dask.array<rechunk-merge, shape=(10,), dtype=float64, chunksize=(4,), chunktype=numpy.ndarray>]

This should also handle mixed dimension arrays sensibly?

The use cases may not be covered by broadcasting, though I feel automatically broadcasting may be useful.  For example, one of my use cases arrays that are not equal size but I prechunked them the way I need, like the following:
import dask.array as da
x = da.ones(10, chunks=(5,))
y = da.ones(20, chunks=(10,))
da.broadcast_arrays(x, y)     # ValueError

We might take some hints from blockwise (for which my gist above also has a workaround to do overlaps on one array).  The work around in blockwise is the align_arrays parameter.  Perhaps we can add that here, to allow people to skip any automatic stuff.

Here's a sketch of one possibility, based on what you guys said (omitting assertions for brevity):
from dask.array.core import map_blocks
from dask.array.core import unify_chunks
from dask.array.overlap import coerce_depth, coerce_boundary, trim_internal, overlap
from tlz import concat

def map_overlap(func, *args, depth=None, boundary=None, trim=True, align_arrays=True, **kwargs):

    def coerce(xs, arg, fn):
        if not isinstance(arg, list):
            arg = [arg] * len(xs)
        return [fn(x.ndim, a) for x, a in zip(xs, arg)]
    depth2 = coerce(args, depth, coerce_depth)
    boundary2 = coerce(args, boundary, coerce_boundary)

    if align_arrays:
        inds = [list(range(x.ndim)) for x in args]
        _, args = unify_chunks(*list(concat(zip(args, inds))), warn=False)

    args = [overlap(x, depth=d, boundary=b) for x, d, b in zip(args, depth2, boundary2)]
    x = map_blocks(func, *args, **kwargs)
    return trim_internal(x, depth2[0], boundary2[0]) if trim else x

That certainly covers my use cases and would have these properties:

It won't work for arrays of different sizes along any one dimension, which I thought was kind of an odd fit for depth values as fixed numbers of cells rather than some kind of percentage
It would work for differing chunk sizes
You can opt out of chunk unification with align_arrays
It wouldn't automatically broadcast all arrays to the same shape (which would be very bad in my case), but users could easily call broadcast_arrays  first if they want a quick fix on chunk alignment and don't care about the data duplication
It would be reverse compatible minus the signature change (question on that later)
Choosing of boundary and depth for the final trim is based on first argument, which is arbitrary but makes it reverse compatible
It would support arrays with different ndim, though the automatic chunk unification means that in order for the blocks to be broadcast together, the unified chunks have to work out to have the same counts along matching broadcast dimensions.  I'm not sure it makes sense to allow this much magical behavior but I suppose it might have some uses:

# Example where things occur as expected:
x = da.ones((10, 1,  1), chunks=((5, 5),    (1,),  (1,)))
y = da.ones((10, 12, 1), chunks=((2,3,5),  (12,),  (1,)))
z = da.ones((10, 12, 8), chunks=((5,3,2),  (12,),  (8,)))
# Func gets called with a row slice from each array (with 2, 3, 3, then 2 rows)
map_overlap(func, x, y, z)
# numblocks after unification: x, y, z = (4, 1, 1), (4, 1, 1), (4, 1, 1)

# More complicated example where this doesn't fail, but the way the blocks
# become broadcastable is somewhat coincidental:
x = da.ones((10,), chunks=((5, 5))) #  <---  (5,5) happens to expand to 4 chunks
y = da.ones((10, 12), chunks=((2,3,5), (6,6)))  #  <--- much like (6, 6) does
z = da.ones((10, 12, 8), chunks=((5,3,2), (4,4,4), (2,2,2,2)))
# Func gets called with 4 row slices from `z` but full copies of other arrays by broadcast
map_overlap(func, x, y, z)
# numblocks after unification: x, y, z = (4,), (4, 4), (4, 4, 4)

At this point it would be easy enough to make my own functions for things like this, but I'd still be happy to push upstream if this is in the ballpark of a good general-purpose solution.  Ultimately, I'd like to see https://github.com/pydata/xarray/issues/3147 happen and I imagine it would be easier with multiple-array map_overlap support here.
Along those lines, how crazy is it to propose something like this in a PR?  Changing these signatures:
def map_overlap(x, func, depth, boundary=None, trim=True, **kwargs): ...
def map_blocks(func, *args, name=None, token=None, ..., **kwargs): ...

to:
def map_overlap(func, *args, depth=None, boundary=None, trim=True, **kwargs): ...
def map_blocks(func, *args, name=None, token=None, ..., **kwargs): ...

Looking at the map_overlap tests and other references, I'm not opposed to trying to change them all but since it'd be my first contribution, it would be great to get a general sense of tolerance for API changes like that.

From my perspective the signature change is fine if we can identify the old form, and change it automatically for the user, while emitting an informative warning.

Is #6165 sufficient to close this issue?

Sure, let's go ahead and close this out. If there are other use cases, it's probably best to start with a new issue :)