RuntimeError: [enforce fail at CPUAllocator.cpp:67] . DefaultCPUAllocator: can't allocate memory: you tried to allocate<PHONE_NUMBER>4 bytes. Error code 12 (Cannot allocate memory)

During the training process I'm getting this error:
RuntimeError: [enforce fail at CPUAllocator.cpp:67] . DefaultCPUAllocator: can't allocate memory: you tried to allocate<PHONE_NUMBER>4 bytes. Error code 12 (Cannot allocate memory)
Epoch 5:  98%|███████████████████████████████████████████████████████████████████████████████████████████████▎ | 3250/3308 [1:10:30<01:15,  1.30s/it, loss=0.165, v_num=0_0]Traceback (most recent call last):████████████████████████████████████████████████████████████████████████████████▏                       | 241/300 [02:57<00:39,  1.50it/s]
  File "./jerex_train.py", line 20, in train
    model.train(cfg)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/model.py", line 341, in train
    trainer.fit(model, datamodule=data_module)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py", line 458, in fit
    self._run(model)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py", line 756, in _run
    self.dispatch()
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py", line 797, in dispatch
    self.accelerator.start_training(self)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/accelerators/accelerator.py", line 96, in start_training
    self.training_type_plugin.start_training(trainer)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/plugins/training_type/training_type_plugin.py", line 144, in start_training
    self._results = trainer.run_stage()
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py", line 807, in run_stage
    return self.run_train()
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py", line 869, in run_train
    self.train_loop.run_training_epoch()
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/training_loop.py", line 576, in run_training_epoch
    self.trainer.run_evaluation(on_epoch=True)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/trainer.py", line 962, in run_evaluation
    output = self.evaluation_loop.evaluation_step(batch, batch_idx, dataloader_idx)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/trainer/evaluation_loop.py", line 174, in evaluation_step
    output = self.trainer.accelerator.validation_step(args)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/accelerators/accelerator.py", line 226, in validation_step
    return self.training_type_plugin.validation_step(*args)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/pytorch_lightning/plugins/training_type/training_type_plugin.py", line 161, in validation_step
    return self.lightning_module.validation_step(*args, **kwargs)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/model.py", line 126, in validation_step
    return self._inference(batch, batch_idx)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/model.py", line 176, in _inference
    output = self(**batch, inference=True)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/torch/nn/modules/module.py", line 889, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/model.py", line 106, in forward
    max_rel_pairs=max_rel_pairs, inference=inference)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/torch/nn/modules/module.py", line 889, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/models/joint_models.py", line 144, in forward
    return self._forward_inference(*args, **kwargs)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/models/joint_models.py", line 233, in _forward_inference
    max_pairs=max_rel_pairs)
  File "/home/marco/.pyenv/versions/PyTorch1.7/lib/python3.7/site-packages/torch/nn/modules/module.py", line 889, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/models/modules/relation_classification_multi_instance.py", line 49, in forward
    chunk_rel_sentence_distances, mention_reprs, chunk_h)
  File "/home/marco/PyTorchMatters/EntitiesRelationsExtraction/jerex/jerex/models/modules/relation_classification_multi_instance.py", line 73, in _create_mention_pair_representations
    rel_ctx = m + h
RuntimeError: [enforce fail at CPUAllocator.cpp:67] . DefaultCPUAllocator: can't allocate memory: you tried to allocate<PHONE_NUMBER>4 bytes. Error code 12 (Cannot allocate memory)

Set the environment variable HYDRA_FULL_ERROR=1 for a complete stack trace.
Epoch 5:  98%|███████████████████████████████████████████████████████████████████████████████████████████████▎ | 3250/3308 [1:10:48<01:15,  1.31s/it, loss=0.165, v_num=0_0]

This is the memory footprint:
 (PyTorch1.7) (base) marco@pc:~/PyTorchMatters/EntitiesRelationsExtraction/jerex$ free -m
              total        used        free      shared  buff/cache   available
Mem:          32059        1670       20587         110        9802       29827
Swap:           979           0         979

How much memory is required and what the minimum requirements (memory, cpu, storage,....) for running the training process?
Which Google Cloud Architecture could be better suited? https://cloud.google.com/tpu/docs/tpus#when_to_use_tpus
Do you think that Google's TPU are a good fit for Jerex Model's tensors shapes and dimensions? https://cloud.google.com/tpu/docs/tpus#shapes

I thought that the model (and training) should fit into 32 GB memory to be honest. Are you sure there wasn't any other memory consuming process running on the system (since the model crashes in the 5. epoch)?
Nevertheless, we have a setting in place that can lower memory consumption. You can reduce the maximum number of spans and mention pairs that are processed simultaneously (in single tensor operations) during training/inference.
Just set the following settings in configs/docred_joint/train.yaml for both training/inference:
training:
(... other settings ...)
max_spans: 200
max_rel_pairs: 50

inference:
(... other settings ...)
max_spans: 200
max_rel_pairs: 50

The settings above work well on a 11 GB GPU (about up to 4 GB of CPU memory is also occupied). By lowering the maximum numbers, memory consumption should be reduced but also model speed. You may tinker with these settings to fit your system.
Regarding TPUs: I would definitely recommend to train the model on a GPU. We get a speedup of more than 10x when training on a single GPU compared to CPU. I do not have any experience with TPUs but I also would expect a speedup here.
Regarding shapes: Since we extract pos/neg samples from documents, it is hard to guarantee equal shapes across batches. This is not ideal speed wise (as is also noticed on your referenced Google document), but you should still gain significant speedups when training on GPUs (and probably also TPUs).

After modifying the training/inference settings it seems that it finally succeeded (it took a while: around 26 hours) :


Design documentation and test strategy

This is a first cut of a design documentation and test strategy for Cucumber. It starts by outlining 3 main components in Cucumber. It then describes how these components communicate over a message protocol.
It goes on to describe 3 different kinds of tests, along with a build system that will generate approval test files as well as living documentation. This is done in a different way from conventional BDD. The test data and documentation are generated from the source code (by annotating the .proto file).
So far I have only implemented the test data generation. What I plan to do next is to implement the approval test suite and run it against @charlierudolph's cucumber-engine.
Then I hope we can start refactoring the native Cucumbers towards becoming front-ends. This should allow us to slim down the codebase considerably.
I am aware there is some reluctance to adopt a go-based engine. It would have to be installed separately, and could either run as a daemon and listen on a socket, or it could be spawned by the front-end and use STDIN/STDOUT.
This does sound a bit scary distribution/installation-wise, I admit that. But I also think it can be a great opportunity both for the users and contributors. Take docker for example. When the installer has run you have a little icon in your task bar where you can do all sorts of configuration. It updates itself when there is a new version. We could evolve it to be a provider of external plugins, such as custom reporters or even test parsers. That would make it really easy to support new formats such as Markdown, Excel or custom formats. This would allow users to truly take advantage of domain-specific models and connect them directly to acceptance tests.
Anyway, have a look and let me know what you think. We can discuss it next Tuesday at the weekly open source call.

/cc @vincent-psarga and @chassa

Whoops I've also made some somewhat unrelated changes to messages.proto. Blame the boy-scout rule!

Thanks for clarifying the testing strategy. I would like to better understand your intention for using Approval Tests.
Cucumer Messages on their own have no value or function that can be tested. They realize their value only when supporting concrete integrations between FrontEnd – Runner or Runner – Reporter. This is what IMHO the testing strategy for Cucumber Messages should describe. Ideally, there would be also a blue-print or specification to build a FrontEnds, Runners or Reporters, on how to integrate through Cucumber Messages with other FrontEnds, Runners or Reporters.
We are currently extending SpecFlow and SpecFlow+ as concrete Engines to support Cucumber Messages. To be more concrete: we want SpecFlow and SpecFlow+ to behave similarly as other Cucumber Engines (legacy and the cross-platform), when it comes to communicating with FrontEnds and Reporters through Cucumber Messages.
This is why we can’t just “implement” Cucumber Messages into SpecFlow/SpecFlow+. We can implement behaviour towards a FrontEnd and/or a Reporter. As a first step, we’re focusing on SpecFlow/SpecFlow+ integrating as Engine to Reporters through Cucumber Messages.
Our decision was driven by what we have jointly agreed on in London at the Cucumber Community meeting: start with integrating Engines with Reporters to add immediate value to our users. Since no Reporter exists yet, we also need a first version of a Reporter that integrates with Engines through Cucumber Messages. To test the general ideas of cross-platform development in the community, we’ve started a cross-platform Reporter to consume Cucumber Messages.
Describing their behaviour of integration from the Engine (SpecFlow/SpecFlow+) and Reporter (first cross-platform version) perspective greatly helps us to move forward in focused way, document what we do, and also spot deviations in the different Engine implementations (e.g. SpecFlow/SpecFlow+).
The only thing that I'm not sure is, whether those specifications should be part of the abstract Cucumber Messages  project, or just concrete FrontEnds, Engines or Reporters that implement Cucumber Messages. Messages itself can never be implemented on their own. Their design emerges and changes from the different use cases we build around Engine-Reporter and FrontEnd-Engine integrations. Still, we could maintain a reference specification to help implement another FrontEnd, Engine or Reporter that integrates successfully with other Cucumber Family components.
My understanding of the purpose for Approval Tests (at least when I discussed the idea with Llewellyn 2012 in Dallas on the AAFTT Open Space) is that they are useful if it is hard to come up with abstract rules and a strict model to describe the assert. E.g. if there are large amounts of data to be described and/or when there is no clear set of rules or good description language on what to assert.
Instead of describing the assert as examples that satisfy rules, Approval Tests take a snapshot of the result which has been validated once as “correct” by a human in an exploratory way (without having a concrete set of rules to assert). An approval test tool can streamline the process of manual re-validation and provides tools for fuzzy result-set assertion.
Asserting graphic output is a good case, @Gojko gives a very good example with @AppraiseQA (see also: https://gojko.net/2017/10/09/introducing-appraise.html).
I currently don't see any of these challenges for describing asserts that test the proper integration of concrete FrontEnd-Engine and Engine-Reporter implementations. Instead, I think that describing the behaviour of those integrations properly in Gherkin is a perfect example for Specification-By-Example.
You could write tests against a concrete Cucumber Engine that implements already Cucumber Messages, to assert the resulting message stream, assuming that this is the "correct" implementation. However, I wouldn't call this approval testing but rather an end-to-end testing safety net approach as described by @michaelfeathers in his book "Working Effectively with Legacy Code". This is if you need to keep a legacy system stable while you refactor it. But do we already have a concrete FrontEnd - Engine or Reporter - Engine combination implemented, that we want to define as "legacy reference" for all the other upcoming implementations?
Approval Tests should be only applied to concrete end-to-end usage scenarios, eg. for an Engine and Reporter successfully producing a "proper" report for test runs. In that case you could assert manually (by looking at it) if the produced report looks "proper", and if so, approve the captured messages as successful result to assert against. Again, I currently would rather describe the behavior of concrete Engines and Reporters that use messages to produce something useful for the user (e.g. perform a report for a test run), as long as rules can be expressed concretely and examples can be described properly in Gherkin. But for certain (graphical) reports, it might be useful for particular Reporters to use approval tests later.
I'd be happy to discuss this in detail in our call on Monday.

https://github.com/cucumber/cucumber/pull/642#issuecomment-504737279
You could write tests against a concrete Cucumber Engine that implements already Cucumber Messages, to assert the resulting message stream, assuming that this is the "correct" implementation. However, I wouldn't call this approval testing but rather an end-to-end testing safety net approach as described by @michaelfeathers in his book "Working Effectively with Legacy Code". This is if you need to keep a legacy system stable while you refactor it. But do we already have a concrete FrontEnd - Engine or Reporter - Engine combination implemented, that we want to define as "legacy reference" for all the other upcoming implementations?

I'm going to second this. As a development strategy I don't believe that starting with the Cucumber Engine is the right approach.
@aslakhellesoy one of your stated goals is to reduce the size of Cucumbers code base. The message protocol is a step towards achieving that goal. However I believe that the goal of implementing the message protocol itself is to provide a unified format for tooling to report on cucumbers execution. I also believe this the goal that we are trying to achieve now.
As such starting with the Cucumber Engine would not be beneficial to achieving that goal. It would add quite some lead time before we can validate the correctness of the message protocol. Additionally it would bet everything on a successful go-hybrid adoption. You'd metaphorically burning the ships.

I am going to need some more time to process everything else that has been said.

If the goal is to focus on the message protocol then I believe the following are the necessary and sufficient components to be successful. As mentioned at Cukenfest:

A description of the message protocol
An implementation of a message protocol message producer
An implementation of a message protocol message consumer
A state machine / state machine description

Used to validate the order of messages produced
Used to generate message in random / all possible valid orders

The state machine essentially describes the contract between producer and consumer.

@chassa I think the highlight on approval testing was a bit misleading in @aslakhellesoy 's summary. Actually what we need is to define a contract and a technique that can be used to verify whether a particular implementation properly handles that contract (this is often called contract testing). Here in our case, since the implementations use/need different platforms, implementing the assertions in the contract tests is problematic and this is what approval testing can support. (This is nothing new, BTW, this is how we have tested the Gherkin parser as well.)
Besides all this, the clean separation of the intention/behaviour and the mechanics of the contract details is anyway useful, as you have said.

I agree, @gasparnagy, we don’t need to argue how to call things, as long as we are aligned on our intentions.
My understanding is, that we want to have a reliable contract between different implementations of FrontEnds, Reporters and Engines in the Cucumber eco system that will evolve over time, as the eco system grows.
For that I think the following two questions are key to answer:

What drives the design of the contract and how do we collaborate on that?
How do we document and share the current design of the contract (which will evolve over time)?

For Q1 I think it is key to define the concrete scenarios for which the contract should emerge, e.g. integration Engine – Reporter. Defining Questions -> Rules -> Key Examples on how the integration should behave is IMHO a good approach for this.
Q2 should follow mostly on how we collaborate in Q1 to keep up with an always up-to-date documentation. I’d imagine Gherkin scenarios would be a natural choice for the Cucumber community.
My current concern is that we skip answering Q1 and discuss options (like state machines or protobuf definitions with inline comments) for Q2, which are completely disconnected from Q1.

Perhaps the approval tests could be an addition to the specification in Gherkin. But so that somebody is able to implement when which message is created, I think approval testing isn't enough. I think it would feel for everybody as reverse engineering something.
I never liked the approval tests of the Gherkin parser.

it's not really easy for a human to check a 140 line json file if it looks correct (e.g. https://github.com/cucumber/cucumber/blob/master/gherkin/testdata/good/docstrings.feature.ast.ndjson)
I see what should be the result, but I don't know how I get to the result.
I never knew, if the actual result is a "better" result than the current

From the little specs we already wrote for cucumber-messages, we got new insights, that we didn't saw only from the messages.proto file. I would miss them, if we didn't had them.

@chassa

Examples on how the integration should behave is IMHO a good approach for this.

I believe those are necessary but not sufficient. Consumer, Producer and State machine each cover different aspects in our process that the other two can't quite cover.

The consumer informs us about the information that should be included in the event stream.
The producer informs us about the events we can provide and their shape.
The state-machine describes possible orders in which the events may be produced and could be consumed.

The examples would do quite well to describe behavior of the producer. They can't however capture the non-deterministic behavior inherent in concurrent execution. Nor can they enumerate all possible sequences of events.
In my experience not designing for concurrency from the ground up is painful.

Design for the cucumber message system.

The producers produces messages that are put into some channel. Multiple producers can use the same channel at the same time. Multiple consumers can listen to a channel. Each consumer will receive a copy of the message put into the channel.
A message consists of producerId which uniquely identifies the producer and an event.

Same system again. But now focused on the interaction between producer and consumer. Both consumer and producer have the same state transition diagram.
The consumer is a validating consumer. As the producer sends messages to the consumer the consumer transitions based on the message received. If the consumer can't transition the message order was invalid and it will be reported.
The producer enumerates all possible message sequences. It does by taking the state transition diagram and selecting an arbitrary transition and sending a message appropriate to this transition.

A class diagram of the minimal set of event types needed to represent everything that happens in a theoretical cucumber execution. I haven't fleshed the contents out much. That can come later on. Important attributes are the timestamp on all events and for all test case events a unique test case identifier.

The state transition diagram as show in figure 2, now in detail.
This is a hierarchical state machine diagram. When entering a state machine state it is not possible to transition out of that state until the final state has been reached.
Also important to note is the e-transition. For clarity I've used a Non-deterministic finite automaton. The e-transition can be invoked arbitrarily without prompting.
In section A the execution of a producer is started by emitting the TestRunStarted event. Nothing need happen and it can immediately be followed by a TestRunFinished event. In between those two events the state machine is allowed to fork into n state machines that execute in parallel. But it can not resume until all forks have been joined.
In section B we see the implementation of state machine B from section A.
Before any TestCaseStarted event 1 or more TestSourceRead events are emited. Once the test case is started it will be executed by machine C. When finished a TestCaseFinished event is emmited.
There is a little bit of contextuallity that isn't possible to capture with an NDFA. The test source that has been read must match the executed test case.
In section C we see the implementation of state machine C from section B.
It is a simple repetition of TestStepStarted and TestStepFinished events between any number of Embed and Write events can happen. Note: In this representation hooks are also considered steps.
A more accurate representation would have 5 copies of statemachine C connected head to tail to cover for before hooks, before step hooks, steps, after step hooks, and after hooks.

I think the next step would be trying to validate if the different Cucumber implementations can be described by this system. If not we have a to have a discussion about the correct implementation of Cucumber first.
Validation could be in the form of a reporter/plugin that outputs a set of minimal events and an implementation of the validating consumer. The reporter/plugin and will also provide us with a nice base system to start iterating further on.
As for the consumer to drive contents of the messages, I believe we specified a minimal example at Cukenfest. It was essentially a feature file augmented with Xs and V behind each step and example. A V indicates a pass, an X a failure.
I.e:
# Comment
@tag
Feature: Eating too many cucumbers may not be good for you

  Eating too much of anything may not be good for you.

  Scenario: Eating a few is no problem
    Given Alice is hungry                              V
    When she eats 3 cucumbers                  V
    Then she will be full                                X

Great insight and illustrations @mpkorstanje! I'm looking forward to studying them and listening to you explaining it :-)
I think the living documentation and executable specification for the
protocol should use a representation that is specific to the domain of protocols.
Protocols are state machines, and the Cucumber Protocol is no different.
There are many ways to document state machines. The most common representation is
State diagrams.
Petri nets can also be used, and they
are sometimes more concise, but since state diagrams are more widely understood
I think we should try that first.
Diagrams convey a lot of information in an way that makes a protocol quick and
easy to understand compared to long-winded textual representations.
Doodling state diagrams on paper seems like a good start, and once we've agreed on the basics
we can formalise it with a state transition table.
This could be a CSV file.
We can then generate a state diagram from the CSV using a bit of scripting and Graphviz
@ciaranmcnulty explained this approach nicely in his Doodle Driven Development presentation at Cukenfest this year.
The transitions in the machine correspond to protocol messages (defined in the .proto file).
With a bit more scripting we can also generate documentation with examples from the CSV file
and the .proto file(s). The examples could be generated from annotations in the .proto
file as I have started to do in this PR.
In other words, the CSV and the .proto files would represent the single source of truth,
and we can use it to generate:

code for the protocol handlers (using a simple parser generator)
automated tests
living documentation (with results from the tests)

This checks all the BDD boxes for me. It doesn't use Cucumber, but I think that is
absolutely fine. I believe in choosing the best tool for the job, and I think
Gherkin falls short in this domain, particularly because it is not visual.
We can still practice TDD with this approach. The first test would be generated from
a simple embryonic transition table with two nodes and one transition. When this test
passes we add another node or transition and keep going until we've implemented the
whole protocol.

Hey @ciaranmcnulty, I'd love your insight on this.


File run causes cov report messed up

I am not sure how test is running for current test file (with require("neotest").run.run(vim.fn.expand("%"))), but the coverage report output is actually for one of the tests cases, instead of summing up of all tests.

Yes, this is (by me) known, actually. It's because the tests are run one by one, even when you run all tests in a file (and when running the entire test suite).
Because of this, you'll always only see the coverage of the last executed test at the end of the execution.
The reason why it works like this is it was the fastest and simplest way to get everything working.
I've been wanting to optimize "run test file" and "run test suite" so that the test results are parsed/collected and the neotest node tree is updated accordingly. This brings a number of benefits such as also being a lot faster.
Unfortunately, there's no workaround for now.

@fredrikaverpil yeah, make sense 👍 One solution is spinning in my mind, what if we will be collecting all test names from file, and the just run them with usual grep, like:
go test -v magnit/mag_collect_service/internal/service/order/issuer -run "^(TestIssuer_NotFound|TestIssuer_WrongState|TestIssuer_IssueCourier_WithCode)" -coverprofile ./coverage.out
Will it be easy to implement?

@quolpr FYI I made some great progress tonight on all this in #24 but it still requires a great deal of work and then a great deal of testing during daily work... so to make sure I catch all bugs and gotchas.

@fredrikaverpil
Wow, such a detailed comment. Thank you for the clarification! Actually, after everything you described, it seems the coverage report might not be a necessary feature, considering the amount of effort required to introduce it. Additionally, it could potentially be buggy.
By the way, don't rush yourself—it's open source! 😅

Also, it's sad that neotest is somehow buggy and we can't use just JSON output. That would solve a lot of problems 🤔 But maintainers don't look to be active for now

it seems the coverage report might not be a necessary feature, considering the amount of effort required to introduce it.

Coverage is always going to be yanky unless you know exactly what you want to measure, and understand which command is the appropriate one to measure that. In this case, if you run a single test case, you'll get coverage for that. But if you run all tests of a file, or all test of a folder, my goal is you should get coverage for that. I view the current behavior of always running tests on a test-by-test case as an "MVP", if you will. It was the fastest way to get something up and working while also learning the Neotest framework.
Proper coverage support by itself might not be a necessary feature, like you say. But the test execution is also extremely inefficient right now. So this is something I want to address, and I believe I've found a great way forward. But I'm starting with "run all tests in a folder (and sub-folders)" as that is a little easier, and can be built upon for "run all tests of a file".

neotest is somehow buggy and we can't use just JSON output.

I guess you are referring to how you get the stdout/stderr output mixed into parsed test results, as I reported in https://github.com/nvim-neotest/neotest/issues/391?
I've found a pretty good workaround though, implemented in the adapter right now, which circumvents that. Basically, the raw output is parsed (as JSON) and afterwards, the file on disk containing the original output is erased, as if there was no output from go test. This means that there is nothing for Neotest to "leak" into its test output window. I think there are no side-effects of this, actually. But I agree, it would be better to get this fixed upstream.

@quolpr in case you want to help out test what I have in #24, just set the branch for your package manager. 😄
It's not exactly what you asked for, as that branch enables running a folder of tests (although it's more of a go package). But it would still be valuable with your input/feedback on how e.g. coverage calculation works for you with this.

@fredrikaverpil wow, thank you for all the work, but I decided to write my own plugin https://github.com/quolpr/quicktest.nvim because I find neotest to be too bloated for me 🤔

Nice work @quolpr ! 👏 🎉
No worries, I wanted to look into this anyway but your input prompted me to look into this sooner than later. Feel free to close this issue if you no longer care to track this. I've still got this on my radar for my adapter.

Just a quick headsup I'm about to merge #92 which fixes this. 😄


Implement hostcall for obtaining server IP

A hostcall to expose the IP address on which the server received the HTTP request was recently added. Support has already been added in the Rust SDK (see https://docs.rs/fastly/latest/fastly/handle/fn.server_ip_addr.html), and needs to be added to the Go SDK.

With https://github.com/fastly/compute-sdk-go/pull/127 merged can we close this?

Done.


Add aws-athena-connector

Hello,
I have created a connector to query AWS S3 bucket data using AWS Athena.
The README.md contains instructions to setup a sample report and the codes are documented. Any feedbacks are welcome :)

Hello @diminishedprime , thanks for the review.
I have updated the data type handling for dates.
Now DATE and TIMESTAMP in Athena will be converted to YEAR_MONTH_DAY and YEAR_MONTH_DAY_HOUR in Data Studio.
And the I have added logic to convert correct data types during the getData() steps.
Please review if the updated implementation looks good to you :) ?


FR: ability to disable context menus

Hi there , I love the idea of the app, but for me, sadly, it was an instant uninstall, because it basically polluted my context menu with things I will never use such as the WhatsApp phone call functionality. If you could add check boxes to each of the functions, that would be awesome.
This app seems to have great potential, and you've done a great job so far, keep it up!

You should try the single variant (app-release-single.apk in the releases section). This will provide you with only 1 option (Text Tools) in the context menu, which will then reveal all the supported options in the apps own UI, which keeps the context menu clean.
Having check boxes to let users what they want in the context menu would be difficult as the context menu entries have to be defined in manifest, and in manifest I am not sure if we can read user preferences to enable/disable an option.

Turns out, it is possible to achieve this. Same has been added in https://github.com/corphish/TextTools/releases/tag/v2.0.0.

Closing this as the FR has been added in v2.0.0.


Forward compatibility with future version of Magnus

Hey, as I mentioned before I've been testing out Magnus API changes against this library to see how things feel in a real project.
This PR collects a handful of changes that will be required with the next major release of Magnus, but can be applied now (I did do a sneaky backport of a couple of very small things to fit them in here).

I've been testing out Magnus API changes against this library

Very appreciated as always. Thanks Mat!


Support for DSF, DFF file

Hello!
Polaris is a great music streaming application, finally found one can browse the music by folder .
I wanna know is it possible to support DSD(.dsf/.dff) file in the future?
Also wanna know is it possible to support .cue file in the future since some of the file is a rip from CD.
Thank You!

I wanna know is it possible to support DSD(.dsf/.dff) file in the future?

That seems unlikely given Polaris does not process media files at all - it just sends them to the browser and it's the browser that decodes them. You would have to get these formats supported by your browser.


Suggestion: support inserting a LICENSE

I suggest a way to specify a full license text (not just a short name). This could be done something like this:
(quickproject:make-project "~/project" :license :gpl3)

Thereby setting *license* to GNU GPL v3 and inserting a LICENSE file with that. This would require keeping quickproject updated with a directory of license texts, however.

The more I consider this the worse this idea seems.


feat: add browser configs

Fixes https://github.com/netlify/eslint-config-node/issues

Should we also add this to the README.md?

Done in https://github.com/netlify/eslint-config-node/pull/57/commits/b8bb6173dd3f570691d8b617a9031ce25063d5c0


Release 1.9.0-up.3

Description of your changes
Update to upbound/crossplane v1.9.0-up.3
Fixes #280
I have:

[ ] Read and followed Upbound's contribution process.
[ ] Run make reviewable to ensure this PR is ready for review.
[ ] Added backport release-x.y labels to auto-backport this PR, as appropriate.

How has this code been tested

@hasheddan thanks!

All checks are passing now.


Can I capture installation changes done by a msi/exe with this sdk?

I want to capture installation changes done by a msi/exe with this sdk.
Thank you.

No, the SDK is not a packaging tool.  We do offer the MSIX Packaging tool from the store as a free tool.  It also comes as a quick create VM. http://aka.ms/msix


Add isServiceRunning method to detect if music service is running

Adds method to check if playback service is running, which is required in android to be able to detect if TrackPlayer methods are safe to call as described here https://github.com/react-native-kit/react-native-track-player/issues/473#issuecomment-528120502 and https://github.com/react-native-kit/react-native-track-player/issues/473#issuecomment-510438390

That is not a complete fix for the mentioned issue, but at least will give an ability to write code in a way that app won't crash on android when service has been stopped by OS

I think we should reject functions instead of adding a new one for that. But we should also check whether the service can be initialized.

@Guichaguri , After leaving this on the back burner for several months, I was literally implementing this method by @biomancer now as a stopgap.
Are you able to share any plans for when you would be able to address this in the way you are recommending?

I think we should reject all methods when the app is in background and the service is not initialized, but also add a function that returns the same condition, so you can add checks instead of handling rejections. (Something like isPlayerUsable() and reject with can-not-initialize)

Somewhat shocked at how long this issue has been open.  People are reporting a 20% crash rate on android devices based on this bug alone; and yet new features like shuffled get prioritized...At the very least, allow this guy's PR to get merged...

Why this PR has not been merged yet?
This error still happens....

Since this was not merged yet + 1 change to list of changes in our fork of this service 🤷♂

We've made a new PR that implements these changes, since this PR's commit history was broken: #1452


Field ordering issue in generated output

Attempting to dump the JSONschema from the pydantic class generated by xsdata-pydantic results in a type error due to field ordering: "TypeError: non-default argument 'name_identifier' follows default argument"
To reproduce:
Source file: https://github.com/datacite/schema/blob/master/source/meta/kernel-4.4/metadata.xsd (plus associated files)
xsdata kernel-4.4/metadata.xsd

then run the following python code:
>>> import pydantic
>>> import generated.metadata as md
>>> print(pydantic.schema_json_of(md.Resource, title="Resource", indent=2))

Output:
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "pydantic/tools.py", line 92, in pydantic.tools.schema_json_of
  File "pydantic/tools.py", line 30, in pydantic.tools._get_parsing_type
  File "pydantic/main.py", line 1026, in pydantic.main.create_model
  File "pydantic/main.py", line 198, in pydantic.main.ModelMetaclass.__new__
  File "pydantic/fields.py", line 506, in pydantic.fields.ModelField.infer
  File "pydantic/fields.py", line 436, in pydantic.fields.ModelField.__init__
  File "pydantic/fields.py", line 557, in pydantic.fields.ModelField.prepare
  File "pydantic/fields.py", line 831, in pydantic.fields.ModelField.populate_validators
  File "pydantic/validators.py", line 725, in find_validators
  File "pydantic/dataclasses.py", line 479, in make_dataclass_validator
    value = f'{default_name}()'
  File "pydantic/dataclasses.py", line 231, in pydantic.dataclasses.dataclass
    def __repr__(self):
  File "pydantic/dataclasses.py", line 224, in pydantic.dataclasses.dataclass.wrap

  File "pydantic/dataclasses.py", line 336, in pydantic.dataclasses._add_pydantic_validation_attributes
    f'eq={self.eq!r},'
  File "pydantic/dataclasses.py", line 391, in pydantic.dataclasses.create_pydantic_model_from_dataclass
    # This function's logic is copied from "recursive_repr" function in
  File "pydantic/main.py", line 1026, in pydantic.main.create_model
  File "pydantic/main.py", line 198, in pydantic.main.ModelMetaclass.__new__
  File "pydantic/fields.py", line 506, in pydantic.fields.ModelField.infer
  File "pydantic/fields.py", line 436, in pydantic.fields.ModelField.__init__
  File "pydantic/fields.py", line 557, in pydantic.fields.ModelField.prepare
  File "pydantic/fields.py", line 831, in pydantic.fields.ModelField.populate_validators
  File "pydantic/validators.py", line 725, in find_validators
  File "pydantic/dataclasses.py", line 479, in make_dataclass_validator
    value = f'{default_name}()'
  File "pydantic/dataclasses.py", line 231, in pydantic.dataclasses.dataclass
    def __repr__(self):
  File "pydantic/dataclasses.py", line 224, in pydantic.dataclasses.dataclass.wrap

  File "pydantic/dataclasses.py", line 336, in pydantic.dataclasses._add_pydantic_validation_attributes
    f'eq={self.eq!r},'
  File "pydantic/dataclasses.py", line 391, in pydantic.dataclasses.create_pydantic_model_from_dataclass
    # This function's logic is copied from "recursive_repr" function in
  File "pydantic/main.py", line 1026, in pydantic.main.create_model
  File "pydantic/main.py", line 198, in pydantic.main.ModelMetaclass.__new__
  File "pydantic/fields.py", line 506, in pydantic.fields.ModelField.infer
  File "pydantic/fields.py", line 436, in pydantic.fields.ModelField.__init__
  File "pydantic/fields.py", line 552, in pydantic.fields.ModelField.prepare
  File "pydantic/fields.py", line 758, in pydantic.fields.ModelField._type_analysis
  File "pydantic/fields.py", line 808, in pydantic.fields.ModelField._create_sub_type
  File "pydantic/fields.py", line 436, in pydantic.fields.ModelField.__init__
  File "pydantic/fields.py", line 557, in pydantic.fields.ModelField.prepare
  File "pydantic/fields.py", line 831, in pydantic.fields.ModelField.populate_validators
  File "pydantic/validators.py", line 725, in find_validators
  File "pydantic/dataclasses.py", line 479, in make_dataclass_validator
    value = f'{default_name}()'
  File "pydantic/dataclasses.py", line 231, in pydantic.dataclasses.dataclass
    def __repr__(self):
  File "pydantic/dataclasses.py", line 207, in pydantic.dataclasses.dataclass.wrap

  File<EMAIL_ADDRESS>line 1185, in dataclass
    return wrap(cls)
  File<EMAIL_ADDRESS>line 1176, in wrap
    return _process_class(cls, init, repr, eq, order, unsafe_hash,
  File<EMAIL_ADDRESS>line 1025, in _process_class
    _init_fn(all_init_fields,
  File<EMAIL_ADDRESS>line 546, in _init_fn
    raise TypeError(f'non-default argument {f.name!r} '
TypeError: non-default argument 'name_identifier' follows default argument

I am getting a bit different errors,
First of all use the xsdata --output pydantic command, I am not sure if the schema_json_of works with normal dataclasses.
Then I get this error
    print(pydantic.schema_json_of(md.Resource, title="Resource", indent=2))
  File "pydantic/tools.py", line 92, in pydantic.tools.schema_json_of
  File "pydantic/main.py", line 675, in pydantic.main.BaseModel.schema_json
  File "pydantic/main.py", line 664, in pydantic.main.BaseModel.schema
  File "pydantic/schema.py", line 186, in pydantic.schema.model_schema
  File "pydantic/schema.py", line 580, in pydantic.schema.model_process_schema
  File "pydantic/schema.py", line 621, in pydantic.schema.model_type_schema
  File "pydantic/schema.py", line 254, in pydantic.schema.field_schema
  File "pydantic/schema.py", line 526, in pydantic.schema.field_type_schema
  File "pydantic/schema.py", line 924, in pydantic.schema.field_singleton_schema
  File "pydantic/schema.py", line 580, in pydantic.schema.model_process_schema
  File "pydantic/schema.py", line 621, in pydantic.schema.model_type_schema
  File "pydantic/schema.py", line 254, in pydantic.schema.field_schema
  File "pydantic/schema.py", line 526, in pydantic.schema.field_type_schema
  File "pydantic/schema.py", line 924, in pydantic.schema.field_singleton_schema
  File "pydantic/schema.py", line 580, in pydantic.schema.model_process_schema
  File "pydantic/schema.py", line 621, in pydantic.schema.model_type_schema
  File "pydantic/schema.py", line 254, in pydantic.schema.field_schema
  File "pydantic/schema.py", line 461, in pydantic.schema.field_type_schema
  File "pydantic/schema.py", line 847, in pydantic.schema.field_singleton_schema
  File "pydantic/schema.py", line 698, in pydantic.schema.field_singleton_sub_fields_schema
  File "pydantic/schema.py", line 526, in pydantic.schema.field_type_schema
  File "pydantic/schema.py", line 921, in pydantic.schema.field_singleton_schema
  File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/abc.py", line 123, in __subclasscheck__
    return _abc_subclasscheck(cls, subclass)
TypeError: issubclass() arg 1 must be a class```

Which is know because of this https://github.com/pydantic/pydantic/issues/3695 we have to tell xsdata to unnest all inner classes.

`xsdata --unnest-classes --output pydantic`

But then I am getting this

raceback (most recent call last):
File "/Users/chris/projects/xsdata-pydantic/scripts.py", line 6, in
print(pydantic.schema_json_of(md.Resource, title="Resource", indent=2))
File "pydantic/tools.py", line 92, in pydantic.tools.schema_json_of
File "pydantic/main.py", line 674, in pydantic.main.BaseModel.schema_json
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/init.py", line 238, in dumps
**kw).encode(obj)
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 201, in encode
chunks = list(chunks)
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 431, in _iterencode
yield from _iterencode_dict(o, _current_indent_level)
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 405, in _iterencode_dict
yield from chunks
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 405, in _iterencode_dict
yield from chunks
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 405, in _iterencode_dict
yield from chunks
[Previous line repeated 2 more times]
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 325, in _iterencode_list
yield from chunks
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 405, in _iterencode_dict
yield from chunks
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/json/encoder.py", line 438, in _iterencode
o = _default(o)
File "pydantic/json.py", line 80, in pydantic.json.pydantic_encoder
File "/Users/chris/.pyenv/versions/3.10.5/lib/python3.10/dataclasses.py", line 1238, in asdict
raise TypeError("asdict() should be called on dataclass instances")
TypeError: asdict() should be called on dataclass instances

Which as far as I can tell it tries to pass the **Meta** class for some reason.

This sounds like a pydantic issue to be honest

Not sure if this is still applicable, I am hoping with the upcoming release, this is also resolved


Fix _GNU_SOURCE imports so that they only affect dlfcn.h

LGTM assuming this works on your system and the Travis instances

Looks like this made the fuzz build sad: https://travis-ci.org/awslabs/s2n/jobs/266104710


[CI] update cuda version and the pipeline

Description
Update TRTLLM pipeline

Build success, merge it now


The system cannot find the path specified.

hi!
I have the same problem. The folder is in the same directory. Solution of the problem is still not there.
I did git clone --recursive git://github.com/microsoft/FFmpegInterop.git and build ffmpeg is got error?
`C:\WINDOWS\system32>"C:\Users\sieu nhan gao\FFmpegInterop\BuildFFmpeg.bat" win10
Verifying ffmpeg directory...
The system cannot find the path specified.
configure is not found in ffmpeg folder. Ensure this folder is populated with ffmpeg snapshot`
#101

Hi @tunerok
Is there a space in the path that you're trying to build?

@khouzam
Path directory is "C:\FFmpegInterop\BuildFFmpeg.bat". No spaces or "not ASCII"-words. CMD run as administrator(root).

Can you comment out the @echo off line in BuildFFmpeg.bat and capture the result?

@khouzam
No problem.

@tunerok,
Can you go into the FFmpegInterop folder and launch the script from there?
I'll update it to change the directory and fix this.

I've pushed the fix, it was trivial.

give me solve it!s


Would you be open to donating this name to the purescript-web organisation?

As per title. :smile:
Didn't realise this was a used name until earlier today when I tried to link against a branch I have in the https://github.com/purescript-web/purescript-web-storage repo!
I'm happy to add you as a maintainer or anything like that, but it would be great if we could get all these libraries under an organisation that can keep them maintained even if individual maintainers have no time or interest in doing so anymore. 🙂

Absolutely, I haven't kept this package up to date and I don't want to be squatting on a valuable name. Do I need to do anything other than use bower unregister, i.e., regarding Pursuit?

I've invited you to the purescript-web organisation, I think that should give you permission to transfer the repository there - no need to unregister or anything, github will put redirects in place so that everything continues to work out.
Thanks!

Bump 🙂

Thanks very much!


helm plugin update doesn't work

Output of helm version:v2.8.2
Output of kubectl version: 1.9.7
Cloud Provider/Platform (AKS, GKE, Minikube etc.):
helm plugin update scale
Error: Failed to update plugin scale, got error (cannot get information about plugin source)
i've already installed a plugin which name scale but when i want to update it i got this error above,
Any hints please how to solve this?  and where we should store our plugins ? how to index them ?
thanks in advance and Regards,

name: "test"
version: "2.0.1"
usage: ""
description: ""
command: "$HELM_PLUGIN_DIR/test"
hooks:
  update: "$HELM_PLUGIN_DIR/install-binary.sh"

why helm plugin update test doesn't work ?    and get   the bellow error :
Error: Failed to update plugin scale, got error (cannot get information about plugin source)

how was this plugin installed?

plugin docs: https://docs.helm.sh/using_helm/#the-helm-plugins-guide

@bacongobbler i installed using this helm plugin install https:/url/plugin.tgz

I saw many plugins are using install and update hooks and it's working for them, i don't know where am I going wrong ?  @bacongobbler

my own plugin and it available on a repository

Try using the clone url rather than a tarball url and see how that goes.

i can't because it's an artifactory all i have it's this tarball url

Closing due to inactivity. Please open a new ticket against Helm 3 if this issue persists. Thanks!


Asyncio servers/clients, large redesign of plugin

I realize that the diff for this PR seems like a huge, backwards incompatible change to the versions before. While a lot of things moved under the hood, the API for the end user stayed mosty the same (see further down). However still, please understand it as a conversation starter, not as a finalized PR.
Also, please don't read the diff (which is a mess), but the actual source code of the branch (which is clean).
This branch started as an attempt to implement the new gRPC Asyncio API. The reason for this was not just for fun or cosmetic, but because certain gRPC features, like interceptors, must be implemented and tested separately for for sync- and async-servers.
With this change, a user can simply request a grpc_stub to run synchronous tests
def test_some(grpc_stub):
    request = EchoRequest()
    response = grpc_stub.handler(request)
    assert response.name == f'test-{request.name}'

or an asio_grpc_stub to run asynchronous tests.
@pytest.mark.asyncio
async def test_some_async(aio_grpc_stub):
    request = EchoRequest()
    response = await aio_grpc_stub.handler(request)
    assert response.name == f'test-{request.name}'

In the background, the appropriate gRPC server is then automatically started up (mixing async with sync client and server is not possible atm). The remainder of the configuration and fixtures stay the same.
Features included in the PR:

asyncio servers and clients
multiple servicers per server
simple channel credential overloading (i.e. SSL)
more examples, and examples are working unittests

However, while developing this, I realized that there are too many places in pytest-grpc that would not really allow the implementation of async-fixtures, without changing those parts of the plugin first. The parts that I changed are:

The original server fixtures are almost completely unchanged. The only change: grpc_servicer was made more similar to grpc_add_to_server and grpc_stub_cls and returns the servicer class, instead of an instance.

The fixture scope was changed to function. There is no reason to use a larger scope than this, and larger scopes really mess with per-function parameterization or simultaneously offering sync and async servers.

The example files were changed to be actual unit tests. This means the examples are not an afterthought, but are immediately runnable and are effectively testing this plugin using the pytest command.

The server/channel credentials were put in special fixtures, so that SSL-tests are much simpler to set up.

Probably the biggest change: the fake classes were removed entirely. I found that they were not API-compatible to the gRPC server and channel classes, and therefore weren't really a transparent drop-in-replacement to the actual server and channels. I think this limits their usefulness for unit testing, as you'd introduce behaviour, side-effects and bugs from your fake classes into your unit tests, and you're not testing the gRPC servicer in isolation, but its interaction with the fake classes...
On the other side, the gRPC team is developing a gRPC testing channel and server classes, too. Right now they do not seem feature-complete and do not seem to offer drop-in-replacement either, however still I would recommend for server/channel-mocking, this plugin should wait until the official test mocks are ready, and use them then.

The way forward: As I said, I am aware this seems like a huge changeset, which makes it a very unattractive merge. However, I believe this design is a true improvement over the design before, and should provide good foundation for future changes.
For most users, I recon, there is only a tiny change they need to make to be compatible to this:

Change the fixture scopes, i.e. @pytest.fixture(scope='module') to @pytest.fixture

Change
@pytest.fixture
def grpc_servicer():
    return Servicer()

to
@pytest.fixture
def grpc_servicer():
    return Servicer

The remainder of changes only affect users who are making very advanced use of this, using fake channels (which were only a run-time optional parameter), or SSL (which is now much easier to use).
I believe these changes are small enough that a major-version release is enough to differentiate between the old API and architecture, and the proposed, new API and architecture.
I am looking forward to hearing your thoughts on this.

@kataev Any chance we can merge this PR. I can help or @nils-werner maintain the project also.

@kataev Any hope here. If you want you can make me maintainer and I can help merge the @nils-werner PR.

Hola Hola, wait a moment

Thanks for the suggested changes.
But why did you decide to rewrite the entire library in asynchronous code and run it under the same name without maintaining backward compatibility?
It seems that your code can be published under a different name and everything will be fine, for example pytest-grpc-async.

The fixture scope was changed to function. There is no reason to use a larger scope than this, and larger scopes really mess with per-function parameterization or simultaneously offering sync and async servers.

Creating a server per test will be slow and seems irrelevant to enabling async? You wouldn't create a new database for every single test function. If you want to test sync and async servers, you could just .. create a second test file? If you want to change this, it should at least be a setting (until https://github.com/pytest-dev/pytest/issues/1681 is implemented )
That said, there's no real lib for testing async grpc right now. Why not make this pr backward-compatible so it can get merged and people can use the async functionality?

That said, there's no real lib for testing async grpc right now. Why not make this pr backward-compatible so it can get merged and people can use the async functionality?

Because development of this lib is dead/stale anyways. A new major release or a new name would have the same effect.

Thank you for your contribution to pytest-grps. I appreciate the time and effort you've put into creating a pull request. After careful review, I have decided that this particular pull request may not align with the goals or direction of the project at this time. However, I wanted to provide some feedback and suggestions for your code.
I believe that your code has potential and could be valuable in a different context. I recommend considering creating a fork repository to showcase your work. This way, your contribution can still be recognized and used by others who may find it useful for their async use cases.
Best regards, Denis.


Docs: Update diagnostics-local.rst [skip ci]

This PR updates diagnostics-local.rst with some corrections to punctuation, naming conventions and other improvements to clarity of sentences. Furthermore, a refactor of the last list has been done in order to match the rest of the documentation's style.

Thanks @farrajota


Update jexcel.js to add in additional TAB functionality

Added some code changes to allow navigation across rows using TAB and also allowing TAB to create a new row when pressed in the last cell of the table

I am working to add that soon.


upgrade Knative deps to 0.18

The scope of this issue is to update KIC's go.mod to use knative.dev/pkg and knative.dev/networking v0.18.
Knative v0.18 comes with support for kubernetes v0.18.8 libs, which invalidates our need for Knative forks where we patched Knative in order to make #713 possible.

closed per #1015

closed per #1015


escape/unescape \v, \b and \f

This does fix partially https://github.com/izimobil/polib/issues/120.
I've left octal/hexadecimal bit patterns because I have no idea on how to do them.

Codecov Report

Merging #123 (c0cec6b) into master (bc4732a) will increase coverage by 0.13%.
The diff coverage is 100.00%.

@@            Coverage Diff             @@
##           master     #123      +/-   ##
==========================================
+ Coverage   95.53%   95.67%   +0.13%
==========================================
  Files           1        1
  Lines         852      856       +4
==========================================
+ Hits          814      819       +5
+ Misses         38       37       -1

Impacted Files
Coverage Δ

polib.py
95.67% <100.00%> (+0.13%)
:arrow_up:

:mega: Codecov can now indicate which changes are the most critical in Pull Requests. Learn more

Sorry for the loooong delay, merged ! thank you very much for this.


configdata.pm.in: Don't try to quotify undefined values

Fixes #10503

Merged.
278de77b881739267d86f96088557af3da966982 configdata.pm.in: Don't try to quotify undefined values


Select 2.0 component (new)

Description

a Select component that allows for typing as well as scrolling through options
similar to autocomplete or combobox

Use cases under consideration

type into field and filter down to options matching query
click something to show the options available
scroll through list and select an option
multi-select
option grouping (or categories)
accessible navigation, option selection and option deletion
system status for slow responding option list
highlight value matches in options

Documentation
Basic
Default view

will look like a standard Select
caret will be grey and have an circle around it to distinguish it from a standard Select
the input field will show the standard input focus style (blue underline) while being interacted with

Active view

clicking the caret will show the Options dropdown
with the dropdown showing, the arrow keys can navigate up or down through options
hitting Enter will select the option and display it in the input field
show up to 10 options at a time
if more than 10 options exist, user will be able to scroll down through them
hover or highlight while scrolling will be the hover grey (#EEE)

Selections

selected option will be the row selection blue (#D9E4EA)

Typing

tabbing into the field will show the cursor in the input field
options are displayed after 1 character has been typed
query values are highlighted bold within each matching option
pressing the down arrow key shows the dropdown
user can tab to the caret and activate the dropdown
tabbing out, clicking outside of, or hitting Escape will close the dropdown

Searching message

if the options come back quickly (< 100ms), show the Options dropdown
if the options load slowly (> 100ms), show the Searching dropdown
Searching message will use the Select's label value

Multiselect

includes all Basic interactions
user can select more than one option by clicking on it or hitting Enter
holding Shift and selecting two separate options will select all options in between them
hitting Enter or clicking outside of the dropdown will make the option visible in the input field as a Label
the Label will have an “X” in it for easy removal
selecting the Label and deleting it will remove it from the selected options

Labels will fill the space available in the inut field and over flow will wrap vertically

Option Groups

options can be displayed on groups with a title

Custom Option Format

option can be formatted in a custom way
can be used to include additional useful data such as images or other data

References

Select 2
ComboBox, Kendo UI
MultiSelect, Kendo UI
Autocomplete Combobox, jQuery
Drop-down Lists & Combo Boxes, Microsoft
Combo Box, Microsoft
Combobox, dfmcfee
Autocomplete, Angular JS
Redesigning the Country Selector, Smashing Magazine

Original request - #90

Closing as duplicate for now.

Regarding accessibility, please make sure to follow these:
https://www.w3.org/TR/wai-aria/roles#combobox
https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_listbox_role

Are configurations such as characters typed until query fired and maximum number of elements to be shown in a dropdown generally exposed or are they going to be constant? Sometimes the rule should be flexible: only after typing N characters should the options be calculated ( because 1 character is not useful against very large datasets)
Will this widget take a configuration object, or will be manually assigning attributes in markup on the component tag?
In the case the select widget in contained within a restricted container that clips, will there be an option to define what node the popup portion of the select list actually binds too? On this subject will the select list be intelligent to cope with common edge cases where visual placement of the select list below the trigger input box would result in truncation? The layout engine should appropriately cause the positioning of the select list to render above the trigger point.

Are configurations such as characters typed until query fired and maximum number of elements to be shown in a dropdown generally exposed or are they going to be constant? Sometimes the rule should be flexible: only after typing N characters should the options be calculated ( because 1 character is not useful against very large datasets)

@reddolan can provide details but from our discussions, it should be configurable (for exactly the use case you mentioned).

Will this widget take a configuration object, or will be manually assigning attributes in markup on the component tag?

We haven't discussed the technical spec for it deeply but that's a good question. cc @youdz

In the case the select widget in contained within a restricted container that clips, will there be an option to define what node the popup portion of the select list actually binds too?

Could you provide more info here? I am not sure I fully understand the use case.

On this subject will the select list be intelligent to cope with common edge cases where visual placement of the select list below the trigger input box would result in truncation? The layout engine should appropriately cause the positioning of the select list to render above the trigger point.

In this one as well, @reddolan would be able to provide more details (and @youdz on the technical side once the spec is ready on that side) but that's a good question and my assumption is that it would either cope with common edge cases or provide alternative experiences there.

Will this widget take a configuration object, or will be manually assigning attributes in markup on the component tag?
As a general rule, Clarity components try to stay away from large configuration objects. So probably attributes in markup. There shouldn't be that many, though, I don't foresee a crazy amount of option that won't be solved by projecting custom content.

In the case the select widget in contained within a restricted container that clips, will there be an option to define what node the popup portion of the select list actually binds too? On this subject will the select list be intelligent to cope with common edge cases where visual placement of the select list below the trigger input box would result in truncation? The layout engine should appropriately cause the positioning of the select list to render above the trigger point.
On this one, @adityarb88 had the issues with dropdowns and tooltips a bunch of times already. I don't believe we have a good universal solution at the moment, we were still investigating last time I checked.

We have the following usecases with Select box:
1.In few configurations inventory might not be synced with the latest information, user should be able to type in the Select box in such cases.
2.In another usecase all the eligible IPs to form a cluster are not available in that use user should be allowed to type in the IP.
In short we need a capability for the user to type in the Select box and would not require an autoComplete in such cases.

We would also like to know if following things are possible:
1.) Fixed width to the select box
2.) In case of fixed widths, the options/selected text could be truncated with ellipsis in case of overflow.

@vkpavan26 are you talking about when a user types in a value that doesn't exist in the available options?

@ajinkyac thank you for sharing these use cases

this should be doable with CSS
It's a valid use case and one we need to look into how we will handle it: option values exceeding the dropdown area width

Does anybody know release date for issue #248?
We need to move on with the development and if this problem will be solved in the near future we would like to use Clarity.
Out technology stack:

Meteor
Angular 2
UI: Clarity / Covalent / Semantic  ... depends on your answer :-)
Thx.

@c0desolut1ons do you have some more information on the application you're planning to build? We don't currently have a timeline for select 2.0 considering the other priorities we're looking at but I'd love to discuss the application you're building and how we can collaborate on delivering this if possible.

@jaffoneh Practically we are planning to develop two applications:

Customer Service App (Meteor, now Angular 4 :-), Clarity UI)
Termin3 Appointment Scheduling web app for clients (we already have the Android app
and now we go a step further) - [https://goo.gl/GHnCQd]
Thx Jaff.

An external contributor is going to start working on a partial version of this component. I don’t want to call it an "MVP", because everyone considers different features to be absolutely necessary. Anyway, he’ll work on select with typing capabilities.
We would like this component to be usable as a simple select in the default case. It will look like this:
<clr-select [(ngModel)]="selected">
    <input type="text" clrSelectInput />

    <clr-option [clrValue]="first">{{first.name}}</clr-option>
    <clr-option [clrValue]="second">{{second.name}}</clr-option>
</clr-select>

The model will be the actual first or second objects, not just their names.
We could potentially make the <input> optional, but let's have it explicitly for now.
In the example above, the options will be in the DOM at all times, just like a native select. But we recommend using the *clrIfOpen directive to only instantiate options when needed:
<clr-select [(ngModel)]="selected">
    <input type="text" clrSelectInput />

    <ng-container *clrIfOpen>
        <clr-option [clrValue]="first">{{first.name}}</clr-option>
        <clr-option [clrValue]="second">{{second.name}}</clr-option>
    </ng-container>
</clr-select>

Obviously, you will be able to generate options dynamically:
<clr-option *ngFor="let option of options">{{name}}</clr-option>

Having the options simply declared in the HTML allows you to display anything you want for them, instead of just a string:
<clr-option *ngFor="let movie of movies">

    {{movie.title}} - {{movie.year}}
</clr-option>

Finally, you might not want to display the same DOM in the dropdown of the select and inside the input. Especially if your dropdown contains images or long descriptions. In this case, you'll be able to display a different label for the option when it is rendered in the input itself:
<clr-select>
    <input type="text" clrSelectInput />

    <ng-container *clrSelected="let movie">{{movie.title}}</ng-container>

    <clr-option *ngFor="let movie of movies">

        {{movie.title}} - {{movie.year}}
    </clr-option>
</clr-select>

The point of this API is also to anticipate on the rest of the features presented, so that they can be added without breaking changes. For instance, a future advanced case might look like this:
<clr-select [(ngModel)]="selectedVideos" [clrMultiple]="true">
    <input type="text" clrSelectInput />

    <ng-container *clrSelected="let video">
        {{video.title}}
        <ng-container *ngIf="video.tv">(TV)</ng-container>
    </ng-container>

    <ng-container *clrIfOpen>
        <clr-option-group>
            <clr-option-title>Movies</clr-option-title>
            <clr-option *ngFor="let movie of movies">

                {{movie.title}} - {{movie.year}}
            </clr-option>
        </clr-option-group>
        <clr-option-group>
            <clr-option-title>TV Shows</clr-option-title>
            <clr-option *ngFor="let show of shows">
                {{show.title}} ({{show.nbEpisodes}} episodes)
            </clr-option>
        </clr-option-group>
    </ng-container>
</clr-select>

Hate to annoy everyone, but is here progress ?

@marvinosswald
Not annoying at all. Thanks for checking in!
We haven't heard from the aforementioned external contributor, so I'm not sure what's being done on that end.
On our end, this is in the top third of our current priorities but is currently not scheduled (meaning it isn't assigned to anyone on our team yet). Given the current priorities on our plate, I don't know if we would be able to start working on this for at least 3 weeks. Maybe longer if our priorities shift.
But it's in line to get worked on. Near the front at this point in time.

Additional features from #980

ability to add new options that aren't part of the option list, done while typing
read-only
validation design

Additional feature request

dividers: to create visual sections, header, or footer

Additional feature request:

Option Groups should be nestable

@marvinosswald can you give us a little more detail on your request about nestable Option Groups? Are you talking about building a visual hierarchy? Do you have an example that you can point to?

Any update on the status of this component? Could you maybe add it to the Component Status page?

@jmcmichael
We had an external contributor working on it who got pretty far with it. But then it appears he stopped working on it or maybe something else came up.
It is currently not one of our top three priorities. But we do plan to work on it in the future.
We're also working on a better way to communicate both our current priorities (and progress on those priorities) as well as our near-future priorities.

@jmcmichael @mathisscott it‘s still in my todo just priorities in my project shifted a little bit which pushed this component a little bit back in our timeline

I was just looking over Clarity's Sketch templates, and noticed the 'Search' component, as well as in the component Status page. Are we discussing the 'Search' component in this issue, or is this about a different component?

@jmcmichael
They’re related but different

@geek-at-heart
The PR still needed some work and had gotten stale over the 0.10 -> 0.11 shift. Someone on the Clarity team is going to take it over and start working on Search 2.0 when they are freed up. We're still figuring out when that will be. Hopefully not too long.
If you stay subscribed to this issue, you should see activity on it when it starts up.

Waiting for this component..

@ajinkyac
I would suggest as a workaround for the long values in options to use substring to truncate teh value if too long, add ellipsis and use this value in the option. You could add the full value as title of option and thus have tooltip.
Regards,
Ledda

Hoping that this component would be available soon.

@gerald-gonzales this is currently under development

Additional feature request...

Display as a static list instead of a dropdown select box; similar to PrimeNG Listbox.

@gperdomor: We plan to start working on implementing this soon. We are in the process of figuring out what features should the first version of Select 2.0 have. Will post more updates here when I have them!

I'm waiting
How long will it be?

@adityarb88 thanks for the response... I need this feature so I'm happy to see your first commit :D. I can't adopt clarity without this :(

It would be great to also have a way to clear the single selection (setting the selected object to null) right from the select, much like ng-select. Like this image...

Thanks for the awesome work.

@shravansofts
This new component will not be in 0.11.

Any progress on this feature?

@yuezhizizhang The implementation of this component has been started and ongoing.

+1

Any idea when will this feature available?

Hi @jayapalapm
Right now, we have moved Select 2 back into our prioritization queue. We will be discussing it in our next quarterly planning (probably in the next few weeks) and determine if it is something that we can pick up between August-February or if it something that will need to be pushed out past next February.
Voices from the community (including thumbsup and +1s) do factor into those discussions.

+1
You may want to create a separate comment for voting as thumbs up/down on the above comment is ambiguous - 'down' could mean 'waaah why is this taking two years?!' or 'I don't need this feature'
As an emergency solution, perhaps it would makes sense to temporarily lean on another ng select2 component, by skinning it to fit in w/ ClarityUI's theme. Honestly I now need to do this myself as I have put off as long as I can developing a field control for an app I'm working on, and am pulling a Tom Sawyer fence-painting trick to maybe get y'all to do it instead. ;) This is the best select component that I could find w/ a permissive license, so I'm going to start with it: https://github.com/ng-select/ng-select

@jmcmichael If you're doing this in github or somewhere open, please send me the details, I need this asap and I would want to collaborate.

This is the only thing missing that prevents me from switching to Clarity, so i hope it won't be delayed to next year.

@youdz what branch is this on now?

Right now the partial implementation is on the topic/select2 branch. The branch is quite a bit behind master so you don't want to try to build Clarity from it, but you can browse the select2 code on it.
Because we do not know how long this component is going to be waiting for final implementation, we are planning on merging the partial implementation into master just to keep up with the frequent refactors we go through. Here is the corresponding pull request. This doesn't mean the select2 component will be ready to use when merged. The implementation is still partial and the component will not work correctly at the moment.

Hi all,
today i was playing around with the https://cuppalabs.github.io/angular2-multiselect-dropdown/#/limitbadges multi select box. You can add your own styles to it and so on.
I am far away from being good at css, but if you cannot wait and want to give it a try...
Here you can find my results from todays testing  (a lot of !important, not really the nicest, but it is working quite ok so far and it looks nice in my opinion)

Here you can find a working stackblitz:
https://stackblitz.com/edit/clarity-light-theme-v11-d8su69?
https://clarity-light-theme-v11-d8su69.stackblitz.io/
like i said before, it is far away from perfect, but it could be a good solution if you have no time to wait :)
If anybody has some hints of how to make it even better, please let me know.
And thank you the @Clarity Team for such an outstanding job!

+1
I have gotten almost everything done on clarity (with custom css and such naturally) - all except a grid context menu and now ran into this.
Unfortunately it seems it won't be around for a while so have to look for a third party option (not worth implementing from scratch time wise).

Hi All,
Is there any prognosis, when will this be available in any release?

We ended up having to go with ng-select, but are pretty happy with it.

@geek-at-heart looks good, a clarity skin would be perfect and then I could use it :)

Will this have the ability to filter via a custom search function like ng-select does?

@jacobbutton I believe it should, though the design doesn't really denote that. There will have to be a way to do custom searching to support server driven lists.

Really need this component... Any updates?

@ygoron
The Combobox (a.k.a. Select 2) is in progress. Up-to-date status is always available here.

Accessible multi-select is tricky.  There is some good advice on it at https://www.w3.org/TR/2017/WD-wai-aria-practices-1.1-20170628/examples/listbox/listbox.html

Currently the combobox is not yet released. We made a custom sass file to make this working. This style sheet allows anyone to use ng-select in a angular+clarity project that uses clarity forms.
https://gist.github.com/Mennez/3f8a1fca40dfd6a3daac86d5cd12ea90

Is there any plan to support this before 2.0? If not, I would love to know what's the status of the 2.0 release. A percentage of some sort maybe? 👼

It is in active development and will be in a release as soon as it is ready. We have no delivery guarantees, so any questions about when it will land cannot be answered. You'll all know based on release notes when its available.

Currently the combobox is not yet released. We made a custom sass file to make this working. This style sheet allows anyone to use ng-select in a angular+clarity project that uses clarity forms.
https://gist.github.com/Mennez/3f8a1fca40dfd6a3daac86d5cd12ea90

This scss uses some pre-defined colors. Where are these colors defined?

Currently the combobox is not yet released. We made a custom sass file to make this working. This style sheet allows anyone to use ng-select in a angular+clarity project that uses clarity forms.
https://gist.github.com/Mennez/3f8a1fca40dfd6a3daac86d5cd12ea90

$dark-theme-highlight-color is not defined.

It is pretty clear to everyone in software development that release dates and feature scope are matter to change and not guaranteed at all!
Fair enough!
But a component that has been designed almost 3 years ago, partly implemented more that a year ago in branch, then multiple times rescheduled and not yet released, currently being overdue since 2 days - simply leaves some questions to the users of the design system you're building!
In general I think you guys are building a really great design system, in a perfect open-source manner!
But please, add some more project management and predictability for the users of your design system!!!
Just one picture to make it even clearer ....

the release which is overdue by 2 days is 33% completed (67% unfinished!)
the stuff that should be done some day is 20% complete, the gap is just 13% ...

Currently the combobox is not yet released. We made a custom sass file to make this working. This style sheet allows anyone to use ng-select in a angular+clarity project that uses clarity forms.
https://gist.github.com/Mennez/3f8a1fca40dfd6a3daac86d5cd12ea90

$dark-theme-highlight-color is not defined.

Fixed. This was a local SASS color variable. Added the variable to the gist.

There is any progress in this? 50% or 90% done maybe?
About 5 months component is in active development phase... maybe it's time to release it in parts? or change the developer? This is a common practice of IT project management, I don’t understand why they are not used on clarity project.
Also, I hope the project manager noticed that this is the most anticipated component at this moment.

@TrifonovSergey
The combobox has been impacted by two separate efforts.

The smart popovers. It made no sense to complete the combobox without smartly positioning its dropdown.
A company-wide focus on accessibility improvements across all products (even Clarity). All development for Clarity was put on pause for 2.5 months to focus on fixing critical accessibility issues and backporting them to 1.0. This effort needed to reach conclusion by September.

For what it's worth, our zenhub board is open to the public so you can see exactly what's in flight.
Also, fwiw, there is a test page for the combobox in its current state at http://localhost:4200/combobox/basic if you fork or clone our repo and run npm start in terminal. You can see it there. It's not ready for release and there's still some work we need to do with it. But, if I'm not mistaken, I believe the public-facing API is fairly stable.
The combobox should be back in development soon. Thanks for the interest. We would love nothing more than to get it released.

@mathisscott thank you very much for the detailed answer! Now the situation with this task and focus of the project is clear for me.
We look forward to the release of this component, which, as I understand, will not be earlier than November.

I follow too, the Clarity autocomplete function is too important.

I'm very interested in this feature as well.  I'm strongly considering Clarity for my needs and am hoping this feature will be out within the next 1-3 months.
Are their any updates on a possible release time frame?

All I can say is it is in progress and we hope the timeline is soon. We've got a Datalist component that should land for v3, so that can also help for many use cases.

All I can say is it is in progress and we hope the timeline is soon. We've got a Datalist component that should land for v3, so that can also help for many use cases.

Oh wow, so we're not making v3 either?
3 Year Anniversary of this component!

Understanding question: Autocomplete is not ready yet?

@webia1
For a simple autocomplete form field, checkout the datalist component in 3.0
For more complex autocomplete fields, @Jinnie and @hippee-lee can provide an update

oooh, any idea if this will make it into v3 ? I need this so badly ...

ETA on this would be exceedingly helpful.  We are preparing a new project and I would prefer to use Clarity over Angular Material.  Can make adjustments to code around this if I know it's coming.

@HarperHampton and @jmls
There is a WIP branch in review right now. I don't think this will be in 3.0 but I believe we are planning to have it ready for 3.1 – which should land shortly after 3.0.
I think time-wise that puts this on the 4-6 weeks away timeframe. Maybe sooner. Maybe later. Depends...

@jinnie - left a note in the Figma file - all dark theme colors specified there. also: changed the dismiss X to 5px - let me know if you have any thoughts, questions.

is the development of this component further pursued or will this be replaced by datalist?
https://clarity.design/documentation/datalist

@d-m-s The datalist is a lightweight HTML element that we could easily support. The combobox is still being built to work for more complex situations, so you'll have both options.

@d-m-s combobox has an open pull request thats currently under review if you want to take a look at it while it gets polished: https://github.com/vmware/clarity/pull/4286

@hippee-lee when can we expect combobox release? I am waiting for the multi select functionality.

Hi @shankar1318  - please follow the PR https://github.com/vmware/clarity/pull/4286. It is almost through the review process. Once that gets merged and is in master it will go into Clarity v4. We are testing with Angular 10.0.0-rc.0 this week to prepare for Angular v10 coming soon.

good to see such a control coming out. Is there a plan for a Search widget that would be similar ? could maybe even restyle this one as I've been thinking of a search (type anything) + filter combo like this:

@adumesny We don't have any design or explorations for something like this, but I believe the combobox can provide you most of what you really need here. I don't really understand the mechanics or use case of this control at this moment.

@gnomeontherun even if you ignore my custom design (search + filter) a simple search field with type ahead suggestions like this new comboBox (but with highlighting of the matching pattern) would be great. Every product seem to re-create their search...

Hi @shankar1318 - please follow the PR #4286. It is almost through the review process. Once that gets merged and is in master it will go into Clarity v4. We are testing with Angular 10.0.0-rc.0 this week to prepare for Angular v10 coming soon.

@hippee-lee will this be available in the previous versions of Clarity?

The combobox is finally officially in our repo, waiting for the next release.
Please add all related problems, suggestions for improvements, direct contributions with code, design, documentation, etc, in separate issues or pull requests, so they can get focused attention and prioritization.
Thank you!

@Jinnie Any idea when this will end up in the v4.next package? I have been eagerly waiting for this ;)

Its available in<EMAIL_ADDRESS>


Use multiple colors for multiple clicked vars in the same algorithm

Extension of #1236.
Right now, all clicked vars in an algo share the same yellow color. This is fine when you only click one of them, but as soon as you click two, the ability to see data flow is impacted.
I should generate a dozen or so good colors, and cycle thru them when activating things.

Fixed in 951e7b470416b6a5244aaf48ce985558817bcacc, forgot to tag the issue in the commit message.


Show Warning when zero routes configured

🧩 Feature request
Lots of first time scully users are starting to work with Scully, and they are generating blank projects that have zero routes. We need to have Scully render the base route / when zero routes are configured. And we need to show the users an error/warning that they MUST add routes to their Angular app, otherwise scully has nothing to render.

Taken care of in #133


What is a channel in a channel integration framework?

Hi,
I appreciate the documentation, but I wish to know what is a "Channel" or "Channel Provider" in your Dynamics 365 CRM, ERP, XRM
regards,
Singaravelu S

Document Details
⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

ID: 1684446d-59e7-af11-04d4-532e318985b2
Version Independent ID: 5ed8bc7a-dc8e-465d-cf31-0f3f1e68b5d8
Content: what is Channel Integration Framework (CIF)
Content Source: ce/developer/channel-integration-framework/overview-channel-integration-framework.md
Service: dynamics-365-cross-app
GitHub Login: @kabala123
Microsoft Alias: kabala

hi @sing-ideas,
Thanks for reaching out and appreciate your time and effort.
Channel may be voice, message, chat, and so on. Where as channel providers are nothing who provides the channels.
For example, Microsoft Skype is a channel provider and Skype provides channels like voice call, video call, and chat.
Hope this helps.
Regards,
Karthik


Add Nature Methods paper link

I tried the doi link for the paper now and got an error:
https://doi.org/10.1038/s41592-019-0627-0

Why is the netlify preview still linking to the old url?

I got the same, I think it may be pre-generated, so take a while to get synced.

Why is the netlify preview still linking to the old url?

No idea, do you mean the one in the engine plugin? I need to update that manually.

I think it was some cache in my browser. Nevermind, it works now.


/wb fill not filling?

Heya,
first sorry for using such a broad title, I know it's not very helpful...
Anyway here is my issue: After I run the command /wb worldX fill the console does output the process succesfully running, however if i do a /dynmap fullrender, my dynmap is still almost entirely empty.
Here is my output:
`

wb worldX fill
[20:00:06] [Server thread/INFO]: World generation task is ready for world "world                                                                                X", attempting to process up to 20 chunks per second (default 20). The map will                                                                                be padded out 208 blocks beyond the border (default 208). Parts of the world whi                                                                                ch are already fully generated will be skipped.
[20:00:06] [Server thread/INFO]: This process can take a very long time dependin                                                                                g on the world's border size. Also, depending on the chunk processing rate, play                                                                                ers will likely experience severe lag for the duration.
[20:00:06] [Server thread/INFO]: You should now use wb fill confirm to start the                                                                                process.
[20:00:06] [Server thread/INFO]: You can cancel at any time with wb fill cancel,                                                                                or pause/unpause with wb fill pause.
wb fill confirm
[20:00:13] [Server thread/INFO]: [WorldBorder] world: worldX  padding: 208  repe                                                                                ats: 1  ticks: 1
[20:00:13] [Server thread/INFO]: WorldBorder map generation task for world "worl                                                                                dX" started.
[20:00:18] [Server thread/INFO]: [WorldBorder] [Fill] 25600 more chunks processe                                                                                d (25600 total, ~8,8%) (free mem: 4343 MB)
[20:00:23] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processe                                                                                d (51456 total, ~17,6%) (free mem: 4247 MB)
[20:00:28] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processed (77312 total, ~26,5%) (free mem: 4618 MB)
[20:00:33] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processed (103168 total, ~35,3%) (free mem: 4518 MB)
[20:00:38] [Server thread/INFO]: [WorldBorder] [Fill] 25600 more chunks processed (128768 total, ~44,1%) (free mem: 4424 MB)
[20:00:43] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processed (154624 total, ~52,9%) (free mem: 4265 MB)
[20:00:43] [Server thread/INFO]: [WorldBorder] [Fill] Saving the world to disk, just to be on the safe side. (free mem: 4265 MB)
[20:00:43] [Server thread/WARN]: A manual (plugin-induced) save has been detected while server is configured to auto-save. This may affect performance.
[20:00:48] [Server thread/INFO]: [WorldBorder] [Fill] 25600 more chunks processed (180224 total, ~61,7%) (free mem: 4584 MB)
[20:00:53] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processed (206080 total, ~70,5%) (free mem: 4477 MB)
[20:00:58] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processed (231936 total, ~79,4%) (free mem: 4378 MB)
[20:01:04] [Server thread/INFO]: [WorldBorder] [Fill] 25856 more chunks processed (257792 total, ~88,2%) (free mem: 4280 MB)
[20:01:09] [Server thread/INFO]: [WorldBorder] [Fill] 25600 more chunks processed (283392 total, ~97,0%) (free mem: 4187 MB)
[20:01:10] [Server thread/INFO]: [WorldBorder] [Fill] 10915 more chunks processed (294307 total, ~100,0%) (free mem: 4165 MB)
[20:01:10] [Server thread/INFO]: [WorldBorder] [Fill] task successfully completed for world "worldX"! (free mem: 4165 MB)
`

If the WB Fill process completes successfully, the world has definitely been generated out to the specified border. Your problem is therefore presumably with dynmap not having a fully updated map.