Should not modify the string inside the explode function

Pint Version: 0.1.7
PHP Version: 8.0

Description:
Pint added spaces between | on explode function.
e.g from explode('|', $string) to explode(' | ', $string)
So, this will give app errors. Is it expected?

Please provide a way to reproduce.

Using this test code:
<?php

$string = 'laravel|team';
explode('|', $string);

I was not able to recreate this issue using any preset in Pint.


Add note for recently moved mailboxes scenario.

If a mailbox is moved, then disabled, the disconnection is delayed for 24 hours to allow for replication. Running Update-MailboxStoreState before the 24-hour timer has expired will have no effect on DisconnectState and DisconnectReason.

Docs Build status updates of commit 3379c7f:
:clock10: Full build: the average full build time is 12 min(s) 7 sec(s), this is based on the last 1000 build(s) for this repository.

Docs Build status updates of commit 3379c7f:
:white_check_mark: Validation status: passed

File
Status
Preview URL
Details

exchange/exchange-ps/exchange/mailbox-databases-and-servers/Update-StoreMailboxState.md
:white_check_mark:Succeeded
View (exchange-ps)

For more details, please refer to the build report.
Note: If you changed an existing file name or deleted a file, broken links in other files to the deleted or renamed file are listed only in the full build report.


Parsing f64 to i32 where the number overflows i32 causes to get the max value instead NA or overflow

Hi all!, I found this by accident, but is not good...:
library(rextendr)
code <- r"(
#[extendr]
fn hello(x: i32) {
    println!("{x}");
}
)"

rust_source(code = code)

hello(8314042901901001)
2147483647

No idea if other type has this behavior, but I think this should never happens.
Thx!

I think we break here https://github.com/extendr/extendr/blob/dd1b050ac4df203de2196bce206caad2c3820cb0/extendr-api/src/robj/try_from_robj.rs#L41C17-L48C18

Yep, we can fix that.
library(rextendr)
code <- r"(
#[extendr(use_try_from = true)]
fn hello(x: i32) {
    println!("{x}");
}
)"

rust_source(code = code)
#> ℹ build directory: 'C:/Users/.../AppData/Local/Temp/Rtmpgzv1Yf/file43c07e48656d'
#> ✔ Writing 'C:/Users/.../AppData/Local/Temp/Rtmpgzv1Yf/file43c07e48656d/target/extendr_wrappers.R'
hello(8314042901901001)
#> Error in hello(8314042901901001): Expected an integer or a float representing a whole number, got<PHONE_NUMBER>901001.0

Created on 2024-04-02 with reprex v2.1.0

wouldn't it be better keep it true as default? or is there a reason for it?

We did not finish the migration fully yet (unfortunately), so not all scenario & type combinations support use_try_from = true. But it should be safe to enable it for functions that are not in impl block.

Wouldn't it be safer not use  as in that sections on the code?


Registration

Enhance the current registration
Events that will trigger the registration process:

A random surfer visits the home page
The random surfer clicks on Worker Registration or Requester Registration
The Registration starts now

Be creative and enhance the suggested workflow to make it better

If the random surfer is a Worker
Form 1: Personal Information
HEADER Highlight the Two Step Registration process

Thumbnail for PERSONAL INFORMATION (ACTIVE)
Thumbnail for SKILLS (FROZEN)

Add the Form Content

Country of Residence
First Name
Last Name
Email
Password
Confirm Password
Phone Number
Click Next

The worker clicks NEXT
Form 2: Skill Information
HEADER Highlight Two Step Registration process

Thumbnail for PERSONAL INFORMATION (DONE)
Thumbnail for SKILLS (ACTIVE)

Add the Form Content

Address
City
Zip Code
Add SSN or Tax Identifier Number (make it optional for now)
Select Skills (from dropdown)
Select three location from where the HITs will be performed
Add social networking profiles (optional) Linkedin/oDesk/MTurk profile
Sign UP Button

If the random surfer is a Requestor
Form 1: Personal Information
HEADER Highlight the Two Step Registration process

Thumbnail for PERSONAL INFORMATION (ACTIVE)
Thumbnail for SKILLS (FROZEN)

Add the Form Content

Country of Residence
First Name
Last Name
Email
Password
Confirm Password
Phone Number
Click Next

Form 2: Skill Information
HEADER Highlight Two Step Registration process

Thumbnail for PERSONAL INFORMATION (Check Box DONE)
Thumbnail for SKILLS (ACTIVE)

Add the Form Content

Address
City
Zip Code
Add SSN or Tax Identifier Number (make it optional for now)
Select Skills (from dropdown)
Select three location from where the HITs will be performed
Add social networking profiles (optional) Linkedin/oDesk/MTurk profile
Sign UP Button

Folders to look at
view: templates/authentication
js: authentication (LoginController and RegisterController)
routes: crowdsource.routes.js

Assigned
GROUP 1
@aditimithal @rushj22 @namchester
GROUP 2
Reach out to DRIs to work on this issue with the GROUP 1

DRI
@neilthemathguy  @dmorina @nistala

Can i do this??

@aditimithal there are a lot of temporary files (ending with ~), could you please remove them?

@phiju123 added you to the group 2.

why are ssn's required for the worker? will they be employees of the platform or contractors?


Update Airbnb info

Update to match the info provided in issue #223

Thank you for your contribution!


Dynamics 365 BC Export-NAVApplicationObjectLanguage Warning

Hi
I exported the Dynamics 365 BC W1 version of the objects from my docker.
Try to export the Native language from this object.
But I got the following warning.

Does anyone know what the reason is?Thanks.

Hi,
Are you using the latest version of the commandlet? The warnings that you see about APIPublisher indicate that you might be using too old of a version of the commandlet compared to the exported .txt file.


Feat/kraken market orders

Before submitting this PR, please make sure:

[X] Your code builds clean without any errors or warnings
[X] You are using approved title ("feat/", "fix/", "docs/", "refactor/")

A description of the changes proposed in the pull request:

Add support for market orders to the Kraken connector
Adds a sample script that places an order that can be used to test order placement functionality on various connectors.

Run the market order script here

Getting OSError: {'error': {'error': ['EOrder:Invalid price:Invalid price argument.']}}2023-12-08 12:00:32,224 - 4703 - hummingbot.connector.exchange.kraken.kraken_exchange - ERROR - Error received from https://api.kraken.com/0/private/AddOrder. Response is {'error': ['EOrder:Invalid price:Invalid price argument.']}.
2023-12-08 12:00:32,225 - 4703 - hummingbot.connector.exchange.kraken.kraken_exchange - NETWORK - Error submitting buy MAKER order to Kraken for 0.20000000 SOL-USDT NaN.
Traceback (most recent call last):
  File "hummingbot/connector/exchange/kraken/kraken_exchange.pyx", line 837, in hummingbot.connector.exchange.kraken.kraken_exchange.KrakenExchange.execute_buy
    order_result = await self.place_order(userref=userref,
  File "hummingbot/connector/exchange/kraken/kraken_exchange.pyx", line 799, in place_order
    return await self._api_request_with_retry("post",
  File "hummingbot/connector/exchange/kraken/kraken_exchange.pyx", line 711, in _api_request_with_retry
    raise e
  File "hummingbot/connector/exchange/kraken/kraken_exchange.pyx", line 694, in hummingbot.connector.exchange.kraken.kraken_exchange.KrakenExchange._api_request_with_retry
    result= await self._api_request(method, endpoint, params, data, is_auth_required)
  File "hummingbot/connector/exchange/kraken/kraken_exchange.pyx", line 722, in _api_request
    async with self._throttler.execute_task(endpoint):
  File "hummingbot/connector/exchange/kraken/kraken_exchange.pyx", line 766, in hummingbot.connector.exchange.kraken.kraken_exchange.KrakenExchange._api_request
    raise IOError({"error": response_json})
OSError: {'error': {'error': ['EOrder:Invalid price:Invalid price argument.']}}

Run the same script on other connectors that support market order, all ok but not with this PR

logs_a.log

@rapcmia I updated the Kraken connector - can you test it out, especially on V2 strategies (ie. Binanc/Kucoin candles + trading on Kraken)


Adapt to coq/coq#12653 (syntax for specifying cumulative inductives)

This should have been merged, Coq CI is currently broken because of this.

It seems there was a race between CI on our side and a merge here such that the need to rebase this PR wasn't detected.
Now rebased, please merge after CI completes.

Thanks for the rebase!


chore: global install, npm ignore

chore: global install, npm ignore

PR-Codex overview
This PR focuses on updating the installation command for ghminer to be installed globally.
Detailed summary

Updated npm install command to install ghminer globally using -g flag.

✨ Ask PR-Codex anything about this PR by commenting with /codex {your question}

@rultor merge

@h1alexbel Done! FYI, the full log is here (took me 7min)


[Snyk] Security upgrade express from 4.16.4 to 4.20.0

Snyk has created this PR to fix 1 vulnerabilities in the npm dependencies of this project.
Snyk changed the following file(s):

package.json
package-lock.json

Vulnerabilities that will be fixed with an upgrade:

Issue
Score

Regular Expression Denial of Service (ReDoS) SNYK-JS-PATHTOREGEXP-7925106
  738

[!IMPORTANT]

Check the changes in this PR to ensure they won't cause issues with your project.
Max score is 1000. Note that the real score may have changed since the PR was raised.
This PR was automatically created by Snyk using the credentials of a real user.

Note: You are seeing this because you or someone else with access to this repository has authorized Snyk to open fix PRs.
For more information:
🧐 View latest project report
📜 Customise PR templates
🛠 Adjust project settings
📚 Read about Snyk's upgrade logic

Learn how to fix vulnerabilities with free interactive lessons:
🦉 Regular Expression Denial of Service (ReDoS)

Checkmarx One – Scan Summary & Details – c5143b2c-fee6-4ff3-a521-70f064c66673
New Issues

Severity
Issue
Source File / Package
Checkmarx Insight

CVE-2021-23440
Npm-set-value-0.4.3
Vulnerable Package

CVE-2021-23440
Npm-set-value-2.0.0
Vulnerable Package

CVE-2023-25344
Npm-swig-1.4.2
Vulnerable Package

CVE-2023-26136
Npm-tough-cookie-2.3.4
Vulnerable Package

CVE-2023-26136
Npm-tough-cookie-2.2.2
Vulnerable Package

CVE-2023-26136
Npm-tough-cookie-2.3.1
Vulnerable Package

CVE-2023-26136
Npm-tough-cookie-2.4.3
Vulnerable Package

CVE-2023-45311
Npm-fsevents-1.2.9
Vulnerable Package

CVE-2024-40643
Npm-htmlparser2-3.8.3
Vulnerable Package

CVE-2022-24999
Npm-qs-6.2.1
Vulnerable Package

CVE-2022-24999
Npm-qs-5.2.1
Vulnerable Package

CVE-2022-24999
Npm-qs-0.6.6
Vulnerable Package

CVE-2022-24999
Npm-qs-6.5.2
Vulnerable Package

CVE-2022-24999
Npm-qs-6.3.2
Vulnerable Package

CVE-2022-25883
Npm-semver-5.6.0
Vulnerable Package

CVE-2022-25883
Npm-semver-5.3.0
Vulnerable Package

CVE-2022-25883
Npm-semver-5.7.0
Vulnerable Package

CVE-2022-3517
Npm-minimatch-3.0.3
Vulnerable Package

CVE-2022-3517
Npm-minimatch-3.0.4
Vulnerable Package

CVE-2022-3517
Npm-minimatch-0.3.0
Vulnerable Package

CVE-2022-38900
Npm-decode-uri-component-0.2.0
Vulnerable Package

CVE-2023-25345
Npm-swig-1.4.2
Vulnerable Package

CVE-2024-27088
Npm-es5-ext-0.10.12
Vulnerable Package

CVE-2024-4068
Npm-braces-2.3.2
Vulnerable Package

Cx10578cb2-c0fc
Npm-cypress-3.3.1
Vulnerable Package

CVE-2017-20162
Npm-ms-0.7.1
Vulnerable Package

CVE-2020-8244
Npm-bl-1.1.2
Vulnerable Package

CVE-2020-8244
Npm-bl-1.0.3
Vulnerable Package

CVE-2023-0842
Npm-xml2js-0.4.4
Vulnerable Package

CVE-2023-28155
Npm-request-2.75.0
Vulnerable Package

CVE-2023-28155
Npm-request-2.88.0
Vulnerable Package

CVE-2023-28155
Npm-request-2.67.0
Vulnerable Package

CVE-2023-28155
Npm-request-2.36.0
Vulnerable Package

CVE-2023-28155
Npm-request-2.79.0
Vulnerable Package

CVE-2024-28863
Npm-tar-2.2.1
Vulnerable Package

CVE-2024-28863
Npm-tar-4.4.8
Vulnerable Package

CVE-2024-4067
Npm-micromatch-3.1.10
Vulnerable Package

CVE-2024-43799
Npm-send-0.18.0
Vulnerable Package

Using Unnamed Build Stages
/Dockerfile: 11
This query is used to ensure that build stages are named. This way even if the Dockerfile is re-ordered, the COPY instruction doesn’t break.


Markdown extensions

I've just started using Fsharp.formatting to process markdown files defining a set of tutorial worksheets for a new F# lecture course at my university next year. It is great having the compiler-generated tooltips and coloring. I have enough time to get the infrastructure right, so I'm wondering how best to do the other things I need.
This issue is because I don't want to reimplement the wheel and would be happy to add to the core code if that was merited (though I doubt it will be). I guess this is a meta-discussion about how to compose non-standard features.
Previously (another language) I was using Pandoc markdown and transforming this to PDF and HTML with Pandoc, where the HTML output was important, and PDF an added bonus but maybe not perfectly formatted.
The features I need and (I think) have not got are:

footnotes (as in pandoc and other extensions)
hyperlinks to additional pages with material for page extracted from the original MD file. I don't know a standard way to do this but for me the utility outweighs the trouble of implementing it myself. The use case is answers to questions in the main file (Pandoc did not do this but I often wanted it and will add the feature now).

So my questions are for these two features:

do they exist at the moment?
does anyone have any advice as to which way to implement if this is done outside the formatting core code? there is a lot of scope for pre-processing input, or processing the formatting parse tree.
should additional features like these be published for others with the formatting code, or is it not worth it?

Best wishes, Tom

Just an update:
I'm writing some code which I will at some time integrate with the main parser as a "optionally switch it in" pass so that anyone not using it will not be worried by potential syntax changes. I need to do a fix for parsing in table cells which at the moment works out column delimiters before parsing inline code etc, and so is broken by '|' characters.

The current strategy is to have a "core" markdown parser (FSharp.Markdown) representing common-mark (well we don't fully conform to the spec at the moment, but that's the idea).
Other features are actually build on top (like handling F# snippets) by walking or extending the "default" tree (FSharp.Literate defines it's own tree by re-using some parts). So if those features can be implemented by transforming an existing tree than this is definitely the way to go (and perfect for composing things). If you encounter problems with this approach feel free to start discussing details as extending the tree is definitely possible.

AFAIK: no
See above
Definitely yes. As long as the extensions conform to the common-mark spec I think they are are nice additions. If we really want a minimal parser we can put such extensions outside of the "FSharp.Markdown" project. But IMHO we are not at this stage jet, as we don't even conform to the common-mark spec.

Thanks @matthid for the answer - I agree with everything!
I think for additional features that cannot be implemented by transforming the parsed Markdown, it would make sense to add them to the core and perhaps enable/disable them with some switch.
But I guess that even with footnotes, you can come up with a syntax that will not require this. For example, you could write them as:
Some text[!footnote](Blah blah blah) some more text

...which will parse as a link, but you can then look for links with a special !footnote text.

Oh, and just for the record, it is amazing to hear that you'll be teaching F# at your university :-).
Any chance your materials will be publicly available? I'm sure many people in the community would be very interested. You could send a PR to add them to the F# Foundation site: http://fsharp.org/teaching/index.html

Hi Tomas,
Thanks for this.
We will see how it goes. The target audience is a bit atypical, they
have learnt C/C++ procedural and done a very basic data structures and
algorithms course, but have no intro to OOP. They are electrical
engineers and hence good mathematicians and (Imperial College) pretty
bright, but have not done much programming - just two modules on our course.
It was a narrow decision between F# and Haskell for this purpose - the
actual module is called "High Level Programming" and after an overview
of FP and OOP I teach a very largely pure functional subset of F#. I
don't see the point in teaching OOP because those who want it can pick
it up vocationally. The difficult bits of OOP like generic
contravariance/covariance get covered anyway in F# with the dreaded
'value restriction'!
For me, the key concepts I want to get across (in lectures backed by a
lot of practical work) are how rich static type systems with inference
can make programs better, and how immutability is worthwhile even when
it seems not to be. The way that types get simpler in an immutable world
is one example of this. These are deep and interesting concepts. I'll
cover OOP by noting the expression problem, and how neither OOP nor FP
have a decent solution. I'll cover state monads using C.E. syntax. So
there is enough complexity for a 3rd year EE module. At the same time
I'll have them doing as much programming as possible with individual
work followed by a large group project, and teach things like testing,
modularity, etc.
F# wins over Haskell because of good tooling and nice syntax, and
(possibly) real world relevance. I'm hoping the complexity of .NET
interoperability, and slight hackiness of F#, can be pushed to one side
since for my target audience this is not relevant when they do the
course. The weakness of F# type system will not matter in practical
terms for them.
I enclose a rough draft of my 1st worksheet which introduces F#. This
will need quite a bit more work, and I'm 12 months still from going live...
I've a question for you. Do you really think the F# one-pass compiler
strategy with its definition order-dependence *within *a module is good?
I don't find it particularly unpleasant, and it allows better type
inference as you type, but it is an unusual design decision. (The choice
to disallow cycles across modules is another matter and can more easily
be justified as a genuine good).
Best wishes, Tom
On 05/04/2016 14:55, Tomas Petricek wrote:

Oh, and just for the record, it is amazing to hear that you'll be
teaching F# at your university :-).
Any chance your materials will be publicly available? I'm sure many
people in the community would be very interested. You could send a PR
to add them to the F# Foundation site:
http://fsharp.org/teaching/index.html
—
You are receiving this because you authored the thread.
Reply to this email directly or view it on GitHub
https://github.com/tpetricek/FSharp.Formatting/issues/391#issuecomment-205816391

#Tutorial 1: types, values and lists
##Prerequisites
You should have Visual Studio & tools set up under Windows to do this Tutorial. F# can also be installed and used under OS-X or linux, however the tooling is not as good as Visual Studio, so these solutions are not preferred.
This introduction assumes you have leant C++. It is not assumed that you are familiar with .NET or OOP in C++.
##F# Language Reference

Syntax
Name
Description

let name [:typename] = exp
let binding
Defines identifier name to be equal to exp  for all subsequent expressions in current block typename is optional because types willbe inferred by compiler.

let fname p = exp
function  let binding
Defines function fname with parameter p to be equal to expression exp which may contain p.

let fname (p : typename) = exp
as above
Types can be added to any parameters as shown

( e1 , e2, ... , en )
n-tuple value
ei can be arbitrary expressions.  Like a record but with unnamed elements  and no type definition

[ e1 ; ... ; en ]
list
All the ei must be the same type. List elements are separated by ; not ,.

[ e1..e2 ]

List of all integers from e1 to e2. e1,e2 must be int. If given float  will generate list of float. If $e2 < e1$ the list will be empty.

fun p1 -> e1
anonymous  function
Identical to name after the binding  let name p1 = e1

( op )
functionised operator
op must be a binary operator.( op ) a b is equivalent to a op b. Mostly used to feed operators to list processing functions

 Figure 1.  F# elements

 **Type and identifier naming**In F# `'` is a valid character in identifiers. Identifiers starting with `'` must be types and the `'` indicates a wildcard (polymorphic) type variable as in `'a list` where `'a` stands for any type.
Identical wildcards within a type specification indicate matching types so:  'a list -> 'b list -> ('a * 'b) list  is different from:
'a list -> 'b list -> ('a * 'a) list

Type
Description

 'a
polymorphic type variable can fit any specific type

int  float  string boolunit
Basic types. unit has a single value of () and  is used when return value is not relevant. Like void but returns a value.

t1 -> t2
Type of function with parameter type t1 and result type t2

t1 * t2
Type of 2-tuple with first element  type t1, second type t2

 Figure 2.  F# Types

Op
Function
Type
Meaning

+ - * /

 float -> float -> float  or  int -> int -> int
overloaded arithmetic  operators use int or float  but cannot mix types

**

float -> float -> float
power operator

float
int -> float
convert int or other numeric type to float

List.map  List.map f lst
('a -> 'b) -> 'a list -> 'b list
map f over lst

List.collect  List.collect f lst
('a -> 'b list) -> 'a list -> 'b list
map f over lst and concatenate the results

List.reduceList.reduce f lst
('a-> 'a -> 'a) -> 'a list -> 'a
reduce list to value using f

List.filter list.filter f lst
('a -> bool) -> 'a list -> 'a list
filter lst to contain  only elements x for which f x = true

`
>`

'a -> ('a -> 'b) -> 'b

Figure 3.  F# Functions and operators

##Introduction
In a functional language, such as F#, every program is a sequence of constant or function definitions, followed by a single expression.

let adj = 3
let opp = 4
let hyp = 5
let square x = x*x
square adj + square opp - square hyp

 Figure 4. F# program

Figure 4 calculates Pythagoras's Theorem for a right-angled triangle. The 4 values defined using let are all used in the final line which calculates any error in the expected hypotenuse length (and will always, in a Euclidean geometry world, be 0). In lines 1-3 the values defined look (and behave) like variables in C with one big difference. They are immutable and so the values defined can't change.
Figure 5 shows the same program written in C++ for comparison:

[lang=cplusplus]
const int adj = 3;
const int opp = 4;
const int hyp = 5;

float square( float x)
{
   return x*x;
}

float main()
{
   return square(adj) + square(opp) - square(hyp);
}

Figure 5. C++ program

Differences between C++ and F# in this example:

Line 4 of Figure 4, defining the square function in F#, uses the same syntax as the first three lines because functions are just values like any other. In Figure 5 the difference is obvious.
Function application in F# does not require brackets square(adj) around the parameter. In a functional languages two expressions placed side by side f g will be evaluated as a function f applied to parameter g as in square adj.
The functional program has no explicit type information! This is not needed because types can be inferred accurately by the compiler. See these by hovering your mouse over them in Figure 4^[This worksheet is written in Markdown and parsed by F# code that uses the compiler API to colorize and generate type lookup tooltips for the code snippets automatically!].
Let bindings, and expressions, are normally terminated by a newline, ; is not needed.

This is a valid, though simple, F# program. It is not however very well written. The problem is that the real calculation, the final line, has data which is baked in via the previously defined parameters adj, opp, hyp. We need to rewrite this as a function with input a triple of values adj, opp, hyp and output the error. In F# any sequence of values separated by , forms a tuple data type and is treated as a single value. This will allow us to rewrite the final line as a function of one 3-tuple parameter using the same syntax is square.

let pythagorasError (adj,opp,hyp) =
   square adj + square opp - square hyp

The brackets are needed around the tuple to prevent a parse error because `,` binds less tightly than almost anything else.
Note that the function definition has been split onto two lines for convenience. The indentation of the second line tells the compiler it is a continuation of the first.
Let us now put this together, nothing that the square function could be a sub-function of pythagorasError if it is not used anywhere else:

let adj = 3
let opp = 4
let hyp = 5

let pythagorasError (adj,opp,hyp) =
    let square x = x*x
    square adj + square opp - square hyp
pythagorasError(adj, opp, hyp)

Figure 6

Note that standard form of the Figure 6 program: again a sequence of let bindings followed by an expression. The body of pythagorasError is indicated by the indentation and it now consists of the square let binding followed by the expression that determines the return value of the function.

Note that a function body (lines 6-7) has the same form as a program.
In line 8 pythagorasError looks like a 3 parameter function in C. In F# it has a single 3-tuple parameter. We will see later on how to write functions with multiple parameters.
Whether functions should be written at top level separately, or included as subfunctions, is a matter of style. Normally single-line functions not used elsewhere would always be written as subfunctions.
Identifiers in F# are case-sensitive. Camelcasing is used to represent multiple words in identifiers: don't use _.

##Types in F#
We have seen in Figure 2 that the types of each identifier do not need to be written by the programmer, thus making the code shorter and easier to read. F# is a strong static typed language, where every identifier has a definite type. Hover your mouse over elements in Figure 6 to discover the types. Note that -> indicates a function type.

**F# tooltips**  The code snippets in this worksheet have been processed by the F# compiler to generate type information that appears on hovering the mouse. Visual Studio does this, with type or syntax errors underlined as you type.

Discover what is the type signature of the 3-tuple parameter to PythagorasError.

In F# as in C++ the normal arithmetic operators +,-,*,/are overloaded and can apply to both int and float numbers (and some other less common types). The functions square and pythagorasError have int type signatures.

Use F# interactive to check what happens when you use pythagorasError with float parameters.
Any identifier id can be marked with a type as (id : int). Rewrite the Figure 2 code replacing adj in pythagorasError by (adj: float). How does this affect the compiler-generated type signature for pythagorasError?

This example shows that in the special case of arithmetic operators F# is more strongly typed than C++. There is no automatic conversion of int to float and so the pythagorasError function can operate on three int or (differently annotated) three float but not a combination. The extra strictness here is in fact helpful, it prevents the incorrect use of integers when floating point numbers^[Many languages would have a Number type that allowed both int and float. More about such types later.] are needed or vice versa. Complete type specification is not needed, in this case just one of the input types (or the output) is enough for the compiler to work out what they all must be. Subfunctions will correctly determine type from their usage, so normally no types need be specified.
##Exercise 1.1
A Pythagorean triple is a set of three integers: $a,b,c: a^2 + b^2 = c^2$. Such sets can be generated from the equation:
Equation (1) $(a^2-b^2)^2 + (2ab)^2 = (a^2+b^2)^2$.
In order to generate a large number of such triples we can apply this for different values of $a,b$.
In pure functional languages it is not possible to use loops and although F# (having procedural elements) does allow this it is almost never the best way to solve problems. In this case we could start with a declarative solution by introducing the list data structure that allows single data values that represent (linked) lists. The pseudocode would be like this:

Input a list of 2-tuples $(a,b)$
For each item in the list apply Equation 1 to generate the Pythagorean triple as a 3-tuple.

Note that lists can contain anything, here 2-tuples and 3-tuples, but that all the elements of a single list must have the same type.
We need one new F# operation to code this. A function which will map a function f over a list lst to perform step 2.

List.map f lst // return a list of f applied in turn
               // to each element of lst

This is a standard List module function in F#. Note that F# is case sensitive (List not list for the module name). You can now write the code:

let pairs = [ (1,2) ; (1,3) ; (2,3); (3,4) ; (4,7) ]
let makeTriple (a,b) = ....
let pythagTriples = List.map makeTriple pairs

(@) Complete the `makeTriple` function definition using Equation 1 and previously defined `square`.
(@) What is the type of: `pairs`, `makeTriple`, `pythagTriples`? in each case see if you can guess the answer.
Test your code in the F# interactive REPL, checking whether your guessed types are correct.
Visual Studio is an IDE that allows an edit/run/debug cycle when writing code. More importantly it has intellisense and autocomplete. These two features are invaluable writing code and can best be understood by trying them out.

Set up a F# VS project as in the install guide with a console application *.fs F# source file.
Type the pythagTriples code into the source file line by line observing the intellisense indications of type and other errors as you type. Hover the mouse over any identifier to get information on its (compiler-inferred) type.
Go to List.map and delete the .map function. Typing . at the end of list will show an autocomplete box of possible List library module functions. Highlighting any one of these will provide further data.
Finally you can get copious data on these functions from MSDN - the fastest way to find this is google search e.g. fsharp List.map. Try this.

(@) Change your working code to make makeTriple a subfunction of pythagTriples. Running as a console application the program requires some extra code to work; a print expression and something to prevent the program from terminating and before you have viewed the output.

printfn "Triples are:%A" pythagTriples
System.Console.ReadLine() // prevent the program from terminating

printfn works like C printf with a newline (printf is also available). note that %A will print out any type in a sensible printable form. You can also you type-specific print specifiers: %s,%d, %f etc.
Printing multiple items requires each expression to be printed to be placed after the printfn specifier string. Compound expressions need to be bracketed.
Multiple expressions in F# are processed sequentially as here printfn before ReadLine(). All expressions except the last must return the unit type which has a single value () and is used when no return value is expected. Printfn returns () since its only purpose is the side-effect of printing.

printfn "print the first 3 powers of 2: %d, %d, %d." 2 (2*2) (2*2*2)
printfn "Look at this Pythagorean triple:%A" (makeTriple(3,4))
printfn "pairs are: %A\n, triples are: %A." pairs pythagTriples

Check that your program works as expected using suitable print statements. Note that even the makeTriple function application needs a bracket for this to work - unlike in C++.
##Exercise 1.2
What if we want to generate the list of pairs automatically - say as all pairs ${(a,b): 1 \leq  a \leq 5, 1 \leq b \leq 5}$? In the spirit of decalarative coding - writing what you want not how to get it - we could write pseudocode:

Let intList = the list of all integers in the range $1 - 5$.
Let pairList = the list of all 2-tupes $(a,b)$ for $a,b \in$ pairList
Let tripleList= the list of all 3-tuples got from applying Equation 1 to pairList.

The F# code is as simple as the pseudo-code!

let intList = [1..5]
let makePairs lst = fun a -> List.map (fun x -> (a,x)) lst //check you understand how this works
let pairList = List.collect (makePairs intList) intList
let makeTriple (a,b) = ... //as before
let tripleList = List.map makeTriple pairList

Three new constructs:

[a..b] denotes the list of numbers from a to b inclusive. In this notation a and b can be any valid expression: [x + 1..x + square a].
In line 2 makePairs is written using inline anonymous functions. Any function let f a = ... can be rewritten as an anonymous function:  let f = fun a -> ...
To understand this test the operation of the inner expression for a fixed a and lst:

let a, lst = 1, [1..5] // note that let bindings can bind tuples as here!
let mp = fun x -> (a,x)
printfn (List.map mp lst)

In line 3 we cannot use List.map again because that would lead to a list of lists of pairs. We need a function like List.map that concatenates all the lists its function generates, List.collect is the standard function that does this.

(@) write this code with suitable print expression etc and check that it works as expected.
(@) Suppose you had made a mistake and used List.map in pairList. Would this lead to a type error, and if so where?
The code now has intermediate values each with a separate name. For complex steps this is what you want because the separate names document the computation and the individual steps simplify the result. Functional programs do not need to name small steps in the computation. This code could better be rewritten:

let pairList = List.collect (fun a -> List.map (fun b -> (a,b)) [1..5]) [1..5]
let makeTriple (a,b) =
    let sq x = x*x
    (sq a - sq b, 2*a*b, sq a + sq b)
let tripleList = List.map makeTriple pairList
printfn "Triples are:%A" tripleList
System.Console.ReadLine() // prevent the program from terminating

Capitalisation in F#.All identifiers are `camelCased` to indicate words and underscore `not_camel_case` is discouraged. The case of the *first letter* of an identifier is confusing because F# conventions and .NET (Microsoft C,C# etc) conventions are different. In F# *user-defined types* should always capitalised. Functions and values are not normally capitalised. However common types shared with C and C# `System.Int`, `System.Float` etc have abbreviations `int`, `float` which are always lower-cased. Similarly the common F# types: `list`,`set`,`array`,`map` ,`string` have lowercase abbreviations which are usually used. Note that *module* `List` contains functions on lists with *type constructor abbreviation* `list`. For now you can nearly always follow the rule: functions and standard types are lower-cased, user types and module names are upper-cased.
Standard module functions which are part of .NET and not in the F# core are capitalised, as are OOP methods which can be used in F# although this will be taught later. Thus System.Console is a .NET module of I/O functions and these (e.g. ReadLine) are capitalised. The standard Fsharp modules for types: List,Map,Array,Set,Stringcontain functions (String.concat, List.map) which are never capitalised. User functions (makeTriple) should normally not be capitalised to distinguish them from user types (used in later Tutorials).Use autocompletion on the module name to check standard function capitalisation if not sure.

(@) Rewrite let makePairs a b = (a,b) as let makePairs1 =... by using an anonymous function. Check makePairs1.
How could we rewrite the code to print a set of lines each containing a pair and the corresponding triple? Thinking declaratively we want:

Modify tripleList to return a list of 2-tuples each containing a pair and its triple
Make a function printTriple x that will print out one element x of the new tripleList
Map printTriple over tripleList using List.map

(@) See if you can do this, looking at the answer if you need inspiration.
The triples produced so far are redundant since $(a,b)$ and $(b,a)$ generate the same triple and $(a,a)$ is not interesting. Let us correct this by writing a function that returns only the pairs in pairList for which $a < b$. There is a library function under the List module that will perform the necessary filtering of a list. Find it using autocompletion on List..
(@) Work out the (single line) function deleteBadPairs x which filters a list of pairs according to the function you have found. You need to know that the operators >,< work as expected on integers to return a boolean value.
The code so far constructs pairList and performs three operations on it in sequence:

deleteBadPairs: filter elements where $a \geq b$
makeTriple: return pairs into Pythagorean triples (in a 2-tuple with the original pair)
printTriple: print each pair with its triple

Each step is a function and what is needed is just:
printTriple(List.map makeTriple(deleteBadpairs(pairList)))
the above code can be written with the pipeline operator as:
pairlist |> deleteBadPairs |> List.map makeTriple |> printTriple
You can see how the pipeline equivalent is easier to read because:

there are no brackets
the functions are written left to right in the order they are used.

(@) Rewrite the code from the last answer using a pipeline.
F# has "standard formatting guidelines" which help to keep code tidy and readable. Visual Studio comes with FSharp Power Tools (see install instructions). If you have these installed, type Ctrl-K Ctrl-D in Visual Studio type to re-indent and format the file being edited, or Ctrl-K Ctrl-F to do this with a highlighted part of the code.
##Exercise 1.3
Write a function expo x n to calculate the first n+1 terms of the Taylor series for exponential $(n \geq 0)$:
$${\tt expo} ; n ;  x = 1+\sum_1^n \frac{x^n}{n!}$$
You will need a new List function:  List.reduce: ('a->'a->'a) -> 'a list -> 'a:

 List.reduce f lst // use f to combine elements of lst
                   // List.reduce f [1 ; 2 ; 3] = f (f 1 2) 3
                   // f = plus => sum the list
                   // f = times => product of the list

You will also need:

**: float -> float -> float defined as a ** b$=a^b$
float: int -> float which converts int type to float. float a is the floating point equivalent of  integer a.
let times a b = a * b convert *(also + etc) into a function to pass to List.reduce .

It is possible to solve the problem without **. Can you see how to do this?

let expo x n =
   let sum a b = a + b
   let times a b = a * b
   let term i = x ** (float i) /
                List.reduce times ([1..i] |> List.map float)
   1 + ([1..n] |> List.map term |> List.reduce sum)

You could implement x ** i as:
[1..i] |> List.map (fun y: y -> x) |> List.reduce times

###Shortcuts

Any binary operator + can be turned into a function using brackets around the operator (+).
The (+) and (*) functions can be written directly into the code without names:

let expo x n =
   let fRange i = [1..i] |> List.map float
   let term i = x ** (float i) / List.reduce (*) (fRange i)
   1 + ([1..n] |> List.map term |> List.reduce (+))

This function is complicated because of the necessary conversion of int values to float.
The 1 + is necessary because List.reduce will not work on zero length lists. Next tutorial you will learn  List.fold which will work on zero length lists and allow a neater solution.

##Assessed Exercise
Write an F# function sineSeries x n which implements the equation below for $n > 0$:
$$ \sin x \approx \sum_0^n (-1)^n\frac{x^{2n+1}}{(2n+1)!}$$
##Summary

This introduction covers basic F# programming and introduces some matters that will be considered in detail later:

Functions with more than one parameter. They are used here but not completely explained. See next tutorial for the concept of currying and high order functions.

Polymorphic types. This tutorial uses them (in list functions) before they have been precisely defined.

Numeric types. There are (complex) ways to make F# functions that will work with both int and float. Many languages have a Number type which contains both int and float. More later.

List functions. Map and reduce (and fold) will be used more later on.

This introduction teaches pure functional code but even so, in order to print results, we have had to depart from that regime with printfn. In fact how best to deal with side effects such as printing in a functional language is an interesting topic we will return to much later.

F# is simple compared with procedural languages. There is no assignment, no statements, no need even for explicit types, although static type checking is strong using inferred types.

Recasting programs with declarative programming generates results without loops. The technique used here is based on knowing how much calculation you want to do (e.g. how many terms of a series) before you do the calculation. It would not work if the problem was to calculate series terms until the value of the current term drops below a given number. There are other ways to deal with this more general type of problem e.g recursion. What is surprising is that so much programming can be done without using loops or assignment.

We can see (a little) from the examples here why functional programming is a useful technique:

It is easy to understand programs which read like maths

It is less common to make mistakes because the start and endpoint of loops are always implicitly given as the length of the list being processed. This and the way that large calculations can be split into multiple small functions creates very robust and error-free programming.

##Extensions

Modify the code for exercise 1.2 so that is prints out only co-prime Pythagorean triples. For example, if $(a,b,c)$ is a triple, and $q$ is an integer, then $(qa,qb,qc)$ is also a Pythagorean triple but not very interesting. You can determine whether a triple has any common factors using the following function which computes the greatest common divisor of two integers:

let rec gcd a b =
  if b = 0
  then abs a
  else gcd b (a % b)

Find Pythagorean triples directly by filtering a list of pairs $(a,b)$ according to whether $a^2+b^2$ is a perfect square. Determine whether there is a perfect square by filtering a list of possible integer square roots. It turns out this "brute force" method properly implemented is very compact. Can you find any Pythagorean triples not of the form used in this exercise?

Thanks for all the information - it is great news :+1:
This sounds like a really important lecture! I think there is a lot of people doing science who learn C/C++ and then use it for all their projects without being aware of alternatives. F# should give them a good idea that there are other options (no matter if they end up using F#, Haskell or something completely different later).
As for the one-pass strategy - I think the requirement of no cycles is mostly a good thing. People in the F# community learned to like it and there are good reasons - here is a nice write-up. I think it is a good default, though having an "escape option" to be used rarely might be useful.
As for the ordering of files itself, I do not really find it a big issue, but for very large projects (like the F# compiler), it would be nice if you did not need it (and the compiler would figure out the order on its own or from some directives). Though in all projects that I significantly contributed to, getting the file ordering right was not such a big deal, so I don't feel strongly about it.

OK - so my comments on the best way to add extensions. I propose:
Use a subset of direct and indirect link syntax in markdown:
body
[body][indirect-link-name]
Here, currently, both body and the link are parsed using bracket matching with a '' standard markdown escape. This is not quite right - because inline code or math should escape the escape. For current usage that is not an issue (though undesirable - a math expression could be displayed with a hyperlink).
So the direct link parser needs to be upgraded a little - easy to do and this is desirable anyway. I've just done something similar to make tables work properly
The links that are escaped to become extension syntax would be:
^!....   - anywhere when parsing plain text
[^!....]:  .... (at start of a paragraph)
There is some possibility of change in spec that affects existing markdown because in principle any character could be the start of a displayed hyperlink but this seems seems pretty safe. Maybe someone has a better combination? Maybe people think a single character (say ^) would be safe enough? If the extensions are not enabled by default this issue is not a problem and a single character would be fine.
The existing code will then generate a parse tree  that can be transformed by the extension code **before ** it is converted to html or latex.
There is an issue about extensions that cannot be expressed as simple markdown.
Specifically, one extension is to allow numbered paragraphs with numbers generated in order throughout the document - suitable for sequential numbered questions etc. Pandoc does this. The problem is that unextended markdown has no way to denote a single numbered list item with arbitrary number. So to implement this we would need a true extension to the parse tree that is recognised by latex and html output processors. The output processor changes would be relatively small, since it is a change to existing list definitions easily possible in both html and latex.
My strategy would be to work on these extensions myself in a fork with a view to merging it back in when they are properly done. Since the extensions are not 100% commonmark compatible (however you define escapes they might be present in a real document) the extensions could be enabled by a processor switch.
Comments?

The first part sounds good to me!
As for the numbered paragraphs - can you point me to some example of how this works in Pandoc? I don't think I've seen these before...

(@) first question
other stuff....
(@) second question
other stuff...
(@) third question
The (@) paragraphs form an ascending numbered list
The use case is when you have a worksheet with interleaved examples and
questions.

I see!
This looks like something that could still be done by running the original parser and then looking for paragraphs that start with (@). You would just need to add your own MarkdownEmbedParagraphs to the AST which represents a block of paragraphs with a number....

Yes, the parsing is no problem.
The issue is that the output (a numbered list item with a specified
number) is different from anything the current writers can generate. A
numbered paragraph would be easy, but a numbered indented paragraph with
hanging indent for the number is not possible.
So this is the most difficult extension to implement.

Just a followup. I've worked out that everything I want can be implemented using HTML tags - easily. So I've added a custom macro expansion to generate the correct tags and all is good without changing the formatting code. That seems the best route for anything complex.
However - in doing this I've found that the markdown in-paragraph formatting breaks (is not processed) after an inserted html tag unless separated by a new markdown paragraph. This is actually inconvenient.
<ul><li>  *This* should be `formatted` **variously**. </ul></li>
Is this a desired feature or a bug? If a bug I'll mend it?

Generally speaking, we should try to do what CommonMark does. I played a bit with this in the playground and it seems to be doing something clever. Can you look at CommonMark and figure out what their specification around this is?

OK - so in fact what happens now for HTML blocks is roughly as in CommonMark. Block characters are escaped until the block ends - which is at the next markdown paragraph boundary.
My problem with the CommonMark spec is that I'm using CSS counters in a list to make numbered paragraphs, and emitting the number with CSS content styling before the list element.
<ul class="question"> <li class="question">

content of list element
</ul> </li>

I can work round this by making the pre-processing insert the question number and not using CSS counters for this purpose.
The only solution I can see here would be an escape as I suggested, which would be harmless, but maybe better I give up trying to use CSS styling.
One issue is whether it is worth a special escape to make CSS styling as above with content work properly?
Another issue is whether it is worth an escape to make hand HTML annotations more readable?
<tag> some stuff I want to pick up HTML style and be processed as markdown </tag>

must be written:
<tag>

some stuff I want to pick up HTML style and be processed as markdown </tag>

an escape would allow:
<tag> <<>> some stuff I want to pick up HTML style and be processed as markdown </tag>

One issue about documentation for newbies running windows and not used to command line.
If I download the repo to a clean system with F# installed it would be good to have simple instructions on how to build for newbies. It is I think:
Start cmd from start menu:
> cd <root directory of fsharp.formatting>
> build clean
> build

I'm not certain whether there are any other prerequisites not downloaded automatically by the build process. Anyway it would be good to document this. I know it seems obvious - but in windows double-clicking build will not work as one might hope.


Build issue with .gz file in cordova android

I am using angular Cli v1.0.0beta17 + Cordova to build a hybrid application.
The debug version is working fine. FYI - I use ng build + cordova build combinations
But when I take production version using ng build --prod and the to build application with cordova build andoid I am getting error.
Further research found out that when ng production build is take (in my case) there are 3 .gz files.
Android aapt does not support building gz file in asset folder. Here are the errors i am getting
`Error: cmd: Command failed with exit code 1 Error output:
FAILURE: Build failed with an exception.

What went wrong:
Execution failed for task ':processDebugResources'.

com.android.ide.common.process.ProcessException: org.gradle.process.internal.E
xecException: Process 'command 'E:\Android Studio\sdk\build-tools\24.0.2\aapt.ex
e'' finished with non-zero exit value 1`

CatBucketConfig]       Unable to add 'E:\xxxxxxxxxxxxxxxx\platforms\android\assets\www\main.69550f811b9602b43919.bundle.js.gz': file already in archive (try '-u'?)
Note - I tried building without gz file and the app got build. But the problem is without the gz files the will only show white screen.
Any help will be appreciated. Thank you very much

The .gz files are completely optional and shouldn't affect your app if they are not there. If you're getting a white screen, there's probably something else is wrong.
Try doing ng build --prod, deleting the .gz files from dist/ and serving it's contents via a http-server or something similar. If you can get a repro that I can use in this scenario, I can help debug.

TL;DR;
1 - ng new angular-test
2 - cordova create cordova-test cordova.test
3 - Merge both contents to the same directory
4 - Change the outDir of angular-cli.json to the www
5 - cordova platform add android
6 - ng build --prod
7 - cordova run android (here it break)
Going further
8 - cd platforms/android
9 - gradlew build --debug (on windows)

Look for the "Unable to add '...\platforms\android\build\intermediates\assets\debug\www\main.adc7a9a050b294c2e7a6.bundle.js.gz': file already in archive"

0 - Have installed the Android SDK or Android Studio 'https://developer.android.com/studio/index.html#downloads'
1 - Install globally both CLI (angular and cordova) - npm i -g angular cordova
2 - Create the directory 'hybrid-test' - md hybrid-test
3 - Enter this directory 'hybrid-test' - cd hybrid-test
4 - Create new ANGULAR project - ng new angular-test
5 - Enter the 'angular-test' directory
6 - Change the outDir of angular-cli.json to the www
7 - Back to the 'hybrid-test' directory - cd ..
8 - Create new CORDOVA project - cordova create cordova-test cordova.test
9 - Enter the 'cordova-test' directory - cd cordova-test
10 - Create the android platform - cordova platform add android
11 - Back to the 'hybrid-test' directory - cd ..
12 - Create the directory 'angular-cordova-test' - mkdir angular-cordova-test
13 - Copy the CONTENTS of both 'angular-test' and 'cordova-test' to the 'angular-cordova-test'
14 - Enter the 'angular-cordova-test' directory - cd angular-cordova-test
15 - Build the angular project to prod - ng build --prod
16 - Run the cordova project - cordova run android

ERROR HERE

17 - Go to the android platform directory - cd platforms/android
18 - Build using Gradle with debug argument - gradlew build --debug (on windows)

Look for the "Unable to add '...\platforms\android\build\intermediates\assets\debug\www\main.adc7a9a050b294c2e7a6.bundle.js.gz': file already in archive"

It already has workaround with the https://gist.github.com/josx/fc76006e6d877b17fefd hook.
https://forum.ionicframework.com/t/android-build-failed-ionic-cordova-unable-to-add-asset-file-file-already-in-archive/41146/5

Would be nice if the Angular CLI come with the outDir default to www. Make it more easily to create and run an angular project in cordova. And could even be explained at docs.

Don't know if it is something the CLI Team should concern, i think it is an aapt.exe error (android sdk build-tools).

I'm sorry but this is not something we're aiming to specifically fix, no. This is something for a user to configure and tool around given it's a specific, alternate usecase.


EBS volume size limits ability to do movie extraction

EBS limit is 16 TB - need to use d2.8xlarge instances to do extraction.
Have to create a new AMI to use instance for extraction:

Spin up d2.8xlarge instance using Ubuntu 16 LTS AMI ?
Perform the following steps to mount 42 TB as raid on /bigdata

$ sudo mdadm --create --verbose /dev/md0 --level=stripe --raid-devices=24 /dev/xvdb /dev/xvdc /dev/xvdd /dev/xvde /dev/xvdf /dev/xvdg /dev/xvdh /dev/xvdi /dev/xvdj /dev/xvdk /dev/xvdl /dev/xvdm /dev/xvdn /dev/xvdo /dev/xvdp /dev/xvdq /dev/xvdr /dev/xvds /dev/xvdt /dev/xvdu /dev/xvdv /dev/xvdw /dev/xvdx /dev/xvdy
$ sudo mkdir /data
$ sudo cat /proc/mdstat
$ sudo mdadm --detail /dev/md0
$ sudo mkfs.ext4 -L MY_RAID /dev/md0
$ sudo mount LABEL=MY_RAID /data

Install Relion-2.0 on instance
Save as new AMI

Adapted from here:
http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/raid-config.html

Worked!
/dev/md0         44T   20K   42T   1% /bigdata

Relion2 installation notes:
$ ssh -X -i relion.pem<EMAIL_ADDRESS>$ sudo apt-get update
$ sudo apt-get install openmpi-bin build-essential libx11-dev libextutils-f77-perl libopenmpi-dev libcr-dev mpich2 mpich2-doc build-essential git cmake libqt4-dev libphonon-dev python2.7-dev libxml2-dev libfltk-gl1.3 libfftw3-double3
$ git clone<EMAIL_ADDRESS>$ cd relion2-beta
$ mkdir build
$ cd build
$ cmake ..
$ make -j 4
$ make -j 4

Need to auto mount RAID array on boot:
LABEL=cloudimg-rootfs	/	 ext4	defaults,discard	0 0
/dev/xvdb	/mnt	ext4	defaults,nobootwait,x-systemd.requires=cloud-init.service,comment=cloudconfig	0	2
LABEL=MY_RAID    /data    ext4 defaults 0 0

Hmm - does not work with ubuntu or Amazon linux to automatically have 42 TB available when booting from snapshot. Will troubleshoot, but workaround will be:

Save AMI with Relion2 on Ubuntu 16
Format raid array before job starts processing

New AMI works - I am able to format drive for instance stores.
However, I think I need to re-write code to:

Launch multiple d2.8xlarge instances for extraction
Move extracted movie particles up to s3
Terminate d2 instance
Boot up x1 instance
Redownload particles
Run auto refine step

First, I will test d2.8xlarge performance alone to do both steps: movie extraction and refinement.


[Scaffold] Wallet Details Screen

This is the detailed address screen, not the initial profile view.

This is out of date; assigning to myself to update.


coqPackages.{bignums, coqprime}: enable for Coq 8.10

Motivation for this change
Libraries for latest version of Coq.
Things done

[ ] Tested using sandboxing (nix.useSandbox on NixOS, or option sandbox in nix.conf on non-NixOS)
Built on platform(s)

[x] NixOS
[ ] macOS
[ ] other Linux distributions

[ ] Tested via one or more NixOS test(s) if existing and applicable for the change (look inside nixos/tests)
[x] Tested compilation of all pkgs that depend on this change using nix-shell -p nix-review --run "nix-review wip"
[ ] Tested execution of all binary files (usually in ./result/bin/)
[ ] Determined the impact on package closure size (by running nix path-info -S before and after)
[ ] Assured whether relevant documentation is up to date
[x] Fits CONTRIBUTING.md.

@GrahamcOfBorg build coqPackages_8_10.coqprime


das: implement DASer

Content

Initial DASer implementation which just listens for headers and DASes them
Adds DASer and Header Service to the node.

Refs
Based on #171
Closes #166

On hold while we add tests.


change case style of errors (errorType instance) to ALL_CAPITALS

changed all occurrences of errorTypes to ALL_CAPITALS, namely

NO_ORDER_TO_CANCEL
VALIDATION_ERROR
ORDER_ERROR
ORDER_UPDATE_ERROR

added hint in description to use case style ALL_CAPITALS for errorType instances

Fixes #103

@ConstantinUp : I don't know who holds the original/editable versions of the figures in the document.
Regarding this PR, also figure 8 should be updated for consistency:

@KIT-IFL : why was branch develop deleted? As described in the README.md, PRs shall be created against this branch (and PRs were actually open and are now deleted)
(same for #188 )


add https support for wrapper integration

add Https suppport for wrapper integration
@flopezag @jframos  @jesuspg

Coverage decreased (-1.48%) to 44.76% when pulling 705e7179366f58d037999f2e70aaa85e8a655f02 on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

Coverage decreased (-1.48%)...

Coverage decreased (-1.15%) to 45.09% when pulling b031a7a0ecc9fea262f4992eaf3f4c3b52388e62 on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

Coverage decreased (-0.32%) to 45.92% when pulling 89853b02a42f26cba580a8263740b388ae82839b on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

Coverage decreased (-0.18%) to 46.06% when pulling 2e730cdf46a71c90a741ee83bf0f1b47aa214576 on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

Coverage increased (+0.32%) to 46.56% when pulling 6697b35d79874c7544b4fe13b8c31f8ca32a080b on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

Coverage increased (+0.27%) to 46.51% when pulling 94f79a6dcf1d78db47ac9d4bdf09619d80ca64f2 on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

Coverage increased (+0.32%) to 46.56% when pulling 523c146a280f0189f6f4d5435e3c777fd44df3c1 on alberts-tid:bug/CLAUDIA-4503 into 00827d3a1fad5a107df5d5bf799b86b4478a7586 on telefonicaid:develop.

LGTM


If we use DYNAMIC_ALLOCATION in BUFRLIB is it zero-diff?

Pursuant to #16, a workaround had to be added to let BUFRLIB build with GCC. The issue is that the current compile strategy for GEOS is to not define -DDYNAMIC_ALLOCATION so it proceed with 'static' I guess. The question is: if we use DYNAMIC_ALLOCATION for Intel as well, do we get the same answer.
An issue was opened with NCEP: https://github.com/NOAA-EMC/NCEPLIBS-bufr/issues/81 and another issue was linked to by @edwardhartnett about moving to dynamic by default: https://github.com/NOAA-EMC/NCEPLIBS-bufr/issues/77 As NCEP might move to DA by default (and I suppose only to dynamic), it would behoove us to test this.
The issue is: I have no idea how to test NCEP_bufr. I know how to do the CMake, but beyond that... 🤷♂
I'm going to assign both myself and @gmao-msienkie only because she is who I think of with "bufr". But if she has a better person in mind, I'll ping/assign them. Once the GEOSadas is (officially) in Git, we can work on this. (though I could also tell someone how to do the same thing in CVS/GNU make)

I don't think that there was any difference in the results when compiling with and without -DDYNAMIC_ALLOCATION, in part because the code runs essentially the same if none of the default settings are changed.  The dynamic allocation allows increasing the maximum sizes of some of the arrays used in the library, and allowed NCEP to retire their 'supersize' build.
I know that we had deliberately chosen to build without dynamic allocation.  There may have been some issue with performance but the real issue was that when I tested running the GSI with the library built with dynamic allocation, back in May 2017, and the program crashed in the 'read_iasi.f90' routine.  From what I could see, the BUFRLIB code sets up things to use the dynamic allocation the first time there is a call to OPENBF.  However, in 'read_iasi.f90' there is a call to CLOSBF before the first call to OPENBF.  The CLOSBF call does nothing because there is no BUFR file open but it runs afoul of the dynamic allocation stuff because it hasn't been set up by the first OPENBF call.  I considered trying to put something at the beginning of the GSI to make sure the stuff for dynamic allocation was intialized before anything was done with any BUFR files - in case there were other cases in the code with a similar problem.  However at the time I decided that we would just stay with our 'static allocation' the way that we had always done it and avoid the issue of having to make it work throughout the code... because the GSI didn't need it and I think there also was mention of a potential performance hit with the dynamic allocation.  (Though of course because of the other issue we did not persue this.)   If you want to pass this information back to NCEP you are welcome.

@gmao-msienkie Thanks. I'll pass it along. That said, it looks like the develop branch of NCEPLIBS-bufr does have newer code in https://github.com/NOAA-EMC/NCEPLIBS-bufr/blob/develop/src/closbf.F where at the top:
#ifdef DYNAMIC_ALLOCATION
      IF ( .NOT. ALLOCATED(NULL) ) THEN
        CALL ERRWRT('++++++++++++++++++++WARNING++++++++++++++++++++++')
        ERRSTR = 'BUFRLIB: CLOSBF WAS CALLED WITHOUT HAVING ' //
     .           'PREVIOUSLY CALLED OPENBF'
        CALL ERRWRT(ERRSTR)
        CALL ERRWRT('++++++++++++++++++++WARNING++++++++++++++++++++++')
        RETURN
      ENDIF
#endif

Perhaps when the develop branch is merged into a new release we might be able to explore this?

Actually, it looks like BUFR 11.3.2 might have the code as well:
https://github.com/NOAA-EMC/NCEPLIBS-bufr/blob/bufr_v11.3.2/src/closbf.F

And the ReleaseNotes note this: https://github.com/NOAA-EMC/NCEPLIBS-bufr/blob/develop/docs/ReleaseNotes.md#version-1132---july-16-2020

Getting back to your original comment about 'how to test NCEP_bufr'.  In the ADAS I believe that the BUFR library is used primarily in running the GSI analysis and in the various preprocessing QC and data manipulation programs under Applications/NCEP_Paqc.  Oh, and of course the EnKF component.  I would usually run some single analysis cases of the GSI to make sure it is working as expected - almost always zero diff.  (I suppose one of Joe's DAS tests could be used for that purpose.) The NCEP_Paqc programs both read and write BUFR files.  I had a script to run the 'gmao_prepqc' by itself (probably needs updating) or I use a 'prepqc.yyyymmdd.hh' working directory from a previous run and try and reproduce the results.  If the BUFR version changes you won't be able to get a zero diff out of 'cmp' but I have some routines to dump the contents of entire BUFR files and the dump files can be compared.
I remember when the BUFR library was updated to replace the Fortran routines for reading BUFR with C routines - there were number of non-zero (but very small) differences in reading BUFR files.  You don't typically expect that with most of the releases - there is added functionality but the old stuff still works the same for the most part.

So I am looking at some new code in the GSI to read high-density radiosondes.  To do this it will require using the dynamic allocation version of the NCEP bufrlib.   I see that the latest version of the NCEP BUFRLIB v12.0.1 has an extension added to support IODA.  It makes me wonder if it would be useful to test our system with the latest BUFRLIB and possibly to have the BUFRLIB and possibly some of the other NCEP libraries mananged through modules instead of using old versions of the code built with the system.  Of course this would require a lot of testing.  Some libraries (like what we call "w3lib") also have a lot of local modifications and acquired some code that actually belonged with other NCEP software.  I think our BUFRLIB is quite "vanilla" so most of our codes should work with an updated version.

edit: for my own testing it would be helpful to get a CMakefile for my own build for compiling for dynamic allocation with the standard Intel compiler.

@gmao-msienkie Here you go:
https://github.com/GEOS-ESM/NCEP_Shared/pull/32
So you can checkout feature/mathomp4/dynamic-bufr locally and try it out. My guess is it'll work.


DocsArchive-<IP_ADDRESS>Auto archive content

Please don't merge this PR until target archive repo PR https://github.com/OPS-E2E-PPE/docs-archive-test-target_48450a59-e8f1-4c5a-a64d-4cbab6d84c1e/pull/1 is merged into live branch.
Auto archive content to https://github.com/OPS-E2E-PPE/docs-archive-test-target_48450a59-e8f1-4c5a-a64d-4cbab6d84c1e.git

Docs Build status updates of commit b3d6f38:
:x: Validation status: errors
Please follow instructions here which may help to resolve issue.

File
Status
Preview URL
Details

:x:Error

Details

[Error]

Cannot sync git repo to specified commit because branch Archive_master_2019-09-29-11-39-59 has been deleted or has been force pushed: fatal: Couldn't find remote ref Archive_master_2019-09-29-11-39-59

For more details, please refer to the build report.
Note: If you changed an existing file name or deleted a file, broken links in other files to the deleted or renamed file are listed only in the full build report.


kak-lsp: 14.1.0 -> 14.2.0

Description of changes
Changelog: https://github.com/kak-lsp/kak-lsp/releases/tag/v14.2.0
In particular, this adds support for workspace/didChangeWatchedFiles events.
I successfully tested an overlay of this, but not this particular commit to nixpkgs.
Things done

Built on platform(s)

[x] x86_64-linux
[ ] aarch64-linux
[ ] x86_64-darwin
[ ] aarch64-darwin

[ ] For non-Linux: Is sandbox = true set in nix.conf? (See Nix manual)
[ ] Tested, as applicable:

NixOS test(s) (look inside nixos/tests)
and/or package tests
or, for functions and "core" functionality, tests in lib/tests or pkgs/test
made sure NixOS tests are linked to the relevant packages

[ ] Tested compilation of all packages that depend on this change using nix-shell -p nixpkgs-review --run "nixpkgs-review rev HEAD". Note: all changes have to be committed, also see nixpkgs-review usage
[ ] Tested basic functionality of all binary files (usually in ./result/bin/)
23.11 Release Notes (or backporting 23.05 Release notes)

[ ] (Package updates) Added a release notes entry if the change is major or breaking
[ ] (Module updates) Added a release notes entry if the change is significant
[ ] (Module addition) Added a release notes entry if adding a new NixOS module

[x] Fits CONTRIBUTING.md.

FYI there is also https://github.com/NixOS/nixpkgs/pull/217658

Yes, shortly after opening this PR I found that one, too. I tried rebasing it, but found that I wasn't completely trivial.

Is there anything blocking this PR? If it can help, I have also tested building with this PR and kak-lsp works correctly.

superseeded by https://github.com/NixOS/nixpkgs/pull/267935


fix #2910 about scan all position

Coverage remained the same at 54.411% when pulling 3417ff731b11cd236fa7bb4ebeae04d9970d9c12 on pengpengshui:master into c21bbbe1e9ea7be33cb329d012460af6bd80f3b2 on vmware:master.

Coverage remained the same at 54.411% when pulling 0966887f9848747b2772e85ff55581d692a7401c on pengpengshui:master into c21bbbe1e9ea7be33cb329d012460af6bd80f3b2 on vmware:master.


Likely a bug

In the method MathNet.Numerics.Providers.LinearAlgebra.SingularValueDecomposition.ManagedLinearAlgebraProvider:
// Place the transformation in v for subsequent back multiplication.
for (i = lp1; i < columnsA; i++)
{
v[(l*columnsA) + i] = e[i];
}
v is a vector here, and l is always 0, so the code should be changed to:
// Place the transformation in v for subsequent back multiplication.
for (i = lp1; i < columnsA; i++)
{
v[i] = e[i];
}

I think I may have been wrong on this one.


Batch operation does not work from Java API

Hi Team,
I tried emulator with docker https://hub.docker.com/r/microsoft/azure-storage-emulator/ . I was able to create the table but batch operation does not work . I get Bad request exception as follows
com.microsoft.azure.storage.table.TableServiceException: Bad Request .
Can someone fix this?
Regards
Abhinav Jain

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

ID: 0bd49c9b-995f-cc7e-77d7-74f21f1249f7
Version Independent ID: 1c2ce65b-5bd3-ca40-a487-ca5059f2c887
Content: Use the Azure storage emulator for development and testing
Content Source: articles/storage/common/storage-use-emulator.md
Service: storage
GitHub Login: @tamram
Microsoft Alias: tamram

@abhinav-jain09 Could you please open an issue in docker's feedback: https://github.com/docker/hub-feedback/issues?q=is%3Aissue+is%3Aopen+sort%3Acomments-desc
This document is not related to your issue on docker, thus the suggested medium would be best to help resolve your issue. I'd also recommend posting on either StackOVerflow or MSDN for a broader audience. cl_


Where's the -- listen

Where's the -- listen,I learned to call the server all the way.

Are you looking for this?


Document expected structure of Jsonnet output

Hi team,
We're trying out tanka for managing our core kubernetes cluster configuration but have hit a few roadbumps.
Most of our problems appear to stem from lack of understanding about what type of object tanka is expecting your jsonnet to generate from the environments file.
From looking at your examples, it appears the implicit expectation is that tanka will recursively descend your jsonnet structure, assuming that your structure is a tree with kubernetes object leaf nodes. So that assumes that you have one global object which is a map of string to object, where that object is either a kubernetes resource or another tree.
data Resource = Resource {
  apiVersion :: String, kind :: String, metadata :: Metadata
}
data Environment = Resource || [(string, Environment)]

If this is so, it would be great to document it. I suspect we might be missing something though, as tanka panics when we construct several otherwise valid configs, such as:
{
  a: {
    apiVersion: 'v1',
    kind: 'List',
    items: [/* valid k8s resources */],
  },
  b: self.a,
}

Lacking a clear explanation about what this format is makes it difficult to adopt tanka as a tool. All the advertising says tanka is a great function, but we don't know what the type signature is.
Can you help us out? Cheers.

Huh, nice catch!! We are indeed expecting a good old JSON dict with the Kubernetes objects as leaf nodes:
{
  "foo": {
    "kind": "Deployment",
    "apiVersion": "apps/v1",
    "spec": {
    }
  },
  "bar": {
    "baz": {
      "kind": "Namespace",
      "apiVersion": "v1",
      "metadata": {
        "name": "baz"
      }
    }
  }
}

The keys don't matter, they are discarded anyways. We were using this pattern internally with ksonnet before.
You are right, we are clearly lacking documentation here :D

Ok, this makes sense. I had a hunch that lists causing a panic was a bug rather than it being totally at odds with the methodology.
So just to make sure we're not doing anything really weird, we've been following a style as advocated by databricks to produce libsonnet files that can template out a , such as a prometheus, or a grafana.
These files look like this, where the individual resources are locals, and we output an api list.
This seemed compelling to us as we have a convention of namespacing all app components together, and wanted to have a good pattern for achieving this without forgetting to apply a namespace anywhere. By outputting a list, we can do this:
{
  local namespace = ...,

  apiVersion: 'v1',
  kind: 'List',
  items: [
    resource {
      metadata+: {
        namespace: namespace.metadata.name,
        labels: $.labels,
      },
    }
    for resource in [
      namespace,
      serviceAccount,
      ...,
    ]
  ],
}

In our top-level environments file, we then merge all these together like so:
local certManager = import 'cert-manager/cert-manager.libsonnet';
local externalDns = import 'external-dns/external-dns.libsonnet';
{
  gcpProject:: 'gc-lab-vault-5e7b',
  certManager: certManager {
    gcpProject: $.gcpProject,
  },
  externalDns: externalDns {
    gcpProject: $.gcpProject,
    domainFilter: ['gocardless.io'],
  },
  ...
}

Obviously this panics given the issue with lists. We got things to work with a hacky PR https://github.com/grafana/tanka/pull/109, but it would be good to know if we're doing something odd or strange here.
Does this look like a valid use of tanka? Have we just got unlucky and hit a bug?
Thanks again for your help, it's really difficult to come across good examples of people using these libraries.

I am not sure, I don't see why this should panic right away ... A List is a valid Kubernetes object and having a List as a leaf node should work .. you will just receive the list in the final output of tk show

Can you share some details on the exact error?

It seems tanka determines what is a kubernetes object by checking if it has apiVersion and kind. Once it's identified these objects, it then attempts to sort them by name, but a list has no name or metadata.
What seemed more natural was for us to expand kubernetes lists into the child resources, so flatten everything into the final output. This would be a more intelligent translation than just recursively stepping through the config structure though, so only makes sense if tanka wants to have an opinion on how to unpack your jsonnet, which is why I was keen to understand what the typing was meant to be.

https://github.com/grafana/tanka/blob/master/pkg/kubernetes/kubernetes.go#L86-L91
That's the line that panics, which will only trigger if you have more than one list object.

Oh yeah, this is kind of naive to expect every object to have Kind and Name. I wasn't expecting List to ever occur, because it is not strictly a real Kubernetes object but rather a helper thing.
TLDR we should fix change that code to just return false in metadata.name is missing on one of these objects.

What is tanka's philosophy on how it should handle the jsonnet output? Should it be totally dumb, and trust it, meaning it's ok if the parsing panics rather than presenting a good error?
Do you think it should be dumb, and never try to intelligently extract kubernetes resources? Unpacking lists, for example, might make a lot of sense to most users.
I'm not sure how much the tanka core devs have a position on this, but it feels worth taking one.

Haha just checked the contributor lists, and it appears you are the core dev. In which case, I'd advise you to have a position on this!
Kustomize has very strong opinions on what it should and should not do. I suspect tanka is more likely to see adoption if it can articulate its own opinions :)

Tanka should never ever panic, if there is an error it needs a good error message that helps the user debug.
Tbh, I haven't really thought about the List type so far, because I have not seen a lot of value in it. Still, your use-case seems valid and it makes sense to flatten it. Would that have any unexpected side-effects that might not be immediately obvious to the user? After all we are mutating THEIR objects here .. they give us a list and tk show would hide that fact.
So we could either go down the path you just proposed, or discourage outputting lists, as it disallows features like Targets.
This whole issue could btw be solved on the Jsonnet level but just flattening the list there ;)

Opinions? /cc @rfratto @malcolmholmes @tomwilkie

I'm not speaking authoritatively here, but I also don't think we should support List. It doesn't appear to be an actual API object and I can't find any documentation for it. In general, I'm not sure I understand why you need the List at all in your example: just exposing the service and deployment objects as keys would be enough to be picked up as API objects, as @sh0rez had shown in his first example.
If it helps, you can see the pattern we've been using to define objects in Loki and throughout our jsonnet libs.

but I also don't think we should support List

I'm also not sure about this. The main reason we were bundling things in a list, other than following the way databricks suggest you do things, was because we wanted to map the namespace across every object. If you have to remember to apply the namespace to each resource definition, it makes it very easy to accidentally miss one and send the resource to the wrong namespace.
It's entirely for the:
    resource {
      metadata+: {
        namespace: namespace.metadata.name,
        labels: $.labels,
      },
    }

Which is replicating the namespace and commonLabels transformers that you get from kustomize.
Is there an easier way to do this in jsonnet?

Yes! The syntax you are using is not specific to your List object.
Imagine you had a local called foo being an array of valid Kubernetes objects:
local foo = [ ... ];

resource + {
  metadata+: {
      namespace: „abc“,
      labels: {}
    }
}

This would overwrite both namespace and labels for all objects in foo

Also keep in mind that by omitting the namespace altogether, Tanka will set the namespace defined in spec.json onto those objects

Ahhh, #112 is what I was missing. It was clear tanka couldn't support lists of resources, and objects in jsonnet aren't functors, in that you can use object comprehensions but they map dicts to lists, rather than dicts to dicts.
If #112 supports lists of resources then we can happily ditch the List type in favour of our jsonnet libraries being structured something like:
{
  namespace:: error 'must provide namespace',
  ...,

  local namespace = ...,
  local deployment = ...,

  resources: [
    resource {
      metadata+: {
        namespace: namespace.metadata.name,
        labels: $.labels,
      },
    }
    for resource in [
      namespace,
      deployment,
      ...,
    ],
  ]
}

Also keep in mind that by omitting the namespace altogether, Tanka will set the namespace defined in spec.json onto those objects

Yep, unfortunately this doesn't work for us. We want to use jsonnet to define an environment per kubernetes cluster and stamp out all the core services we expect to be in the cluster. We separate each core service into its own namespace, so the concept of there being a 'default' namespace that tanka should use is a bit broken for us.
It's why I'm very keen to find a pattern that ensures every resource output by a jsonnet module is namespaced. Accidentally sending a couple of resources for a particular application into the default namespace is not ideal.


Add support for return the type of stream

Add support for return the type of stream 0f16638
Edit test.js, net.Socket() is a stream Duplex 620aeb1

The test fails because net.Socket is a stream Duplex only after Node.js: 14.
I'll do another PR where the tests must pass the NODE versions configured in travis.yml


[request/idea] yakyak (hangouts app, electron)

Issue description
https://github.com/yakyak/yakyak
Building from source is of course ideal, but they do have binary releases as well.
Haven't tried it, but anything would be better than what i have :P.

Sounds good, I'll give it a try!

Hey, just wanted to drop by and see if anyone is still working on it?
I'm pretty new to Nix[pkgs|OS] but I have the same need.
I tried to write a naive derivation using the binary, but it fails with missing (I guess) runtime libraries.
I also tried from source (NodeJS + Gulp project) but I have to admit it seems pretty complex for a noob to write such a derivation.
I can try again but I definitely need guidance :disappointed:
For the binary problem, I've read things around patchELF but this is pretty obscure to me, even with Nix doc on the matter :cry:

I made a PR for this https://github.com/NixOS/nixpkgs/pull/69393 but I bet it may take a while to get it merged.

Hi, I just open a package request, and then after that found this. I believe I need to use this software, but never try it before. Thank you.


The top version is not set for phone layout

What we got:

What it should be (take chaos mesh website for reference):

Hi @Yiyiyimu
I want to try this issue, Please assign this issue to me :)

Hi @juzhiyuan
I knew the version info is wrapped by DocsVersionDropdownNavbarItem, but where can I found more detail about this?
https://github.com/apache/apisix-website/blob/master/website/src/theme/DocSidebar/index.js#L191-L193

Hi @juzhiyuan
I knew the version info is wrapped by DocsVersionDropdownNavbarItem, but where can I found more detail about this?
https://github.com/apache/apisix-website/blob/master/website/src/theme/DocSidebar/index.js#L191-L193

Check out this
https://v2.docusaurus.io/docs/next/using-themes#swizzling-theme-components
https://github.com/facebook/docusaurus/tree/master/packages/docusaurus-theme-classic/src/theme/NavbarItem

Hi @juzhiyuan
I knew the version info is wrapped by DocsVersionDropdownNavbarItem, but where can I found more detail about this?
https://github.com/apache/apisix-website/blob/master/website/src/theme/DocSidebar/index.js#L191-L193

Check out this
https://v2.docusaurus.io/docs/next/using-themes#swizzling-theme-components
https://github.com/facebook/docusaurus/tree/master/packages/docusaurus-theme-classic/src/theme/NavbarItem

Thank you information, I will take a look.


feat: add github enterprise support

Codecov Report
Attention: Patch coverage is 0% with 17 lines in your changes missing coverage. Please review.

Project coverage is 55.51%. Comparing base (fad5678) to head (7fb4a9b).
Report is 2 commits behind head on main.

Files with missing lines
Patch %
Lines

internal/scms/github/git_operations.go
0.00%
11 Missing :warning:

internal/scms/github/commit_status.go
0.00%
2 Missing :warning:

internal/scms/github/pullrequest.go
0.00%
2 Missing :warning:

internal/controller/commitstatus_controller.go
0.00%
1 Missing :warning:

internal/controller/pullrequest_controller.go
0.00%
1 Missing :warning:

Additional details and impacted files
@@            Coverage Diff             @@
##             main      #80      +/-   ##
==========================================
- Coverage   56.13%   55.51%   -0.62%
==========================================
  Files          10       10
  Lines        1133     1142       +9
==========================================
- Hits          636      634       -2
- Misses        420      433      +13
+ Partials       77       75       -2

:umbrella: View full report in Codecov by Sentry.
:loudspeaker: Have feedback on the report? Share it here.


[release] prepare for 1.8.3

1.8.3-SNAPSHOT -> 1.8.3

Codecov Report

Merging #5422 into 1.8.x will increase coverage by 0.01%.
The diff coverage is n/a.

@@            Coverage Diff            @@
##           1.8.x    #5422      +/-   ##
=========================================
+ Coverage   40.6%   40.62%   +0.01%
=========================================
  Files       2653     2653
  Lines      79811    79811
  Branches   10831    10831
=========================================
+ Hits       32411    32421      +10
+ Misses     44461    44447      -14
- Partials    2939     2943       +4

Impacted Files
Coverage Δ

...vercorp/pinpoint/rpc/packet/ClientClosePacket.java
55.55% <0%> (-11.12%)
:arrow_down:

...pc/server/LoggingServerMessageListenerFactory.java
90% <0%> (-10%)
:arrow_down:

...cluster/zookeeper/ZookeeperClusterDataManager.java
62.5% <0%> (-2.21%)
:arrow_down:

...orp/pinpoint/rpc/server/DefaultPinpointServer.java
78.81% <0%> (-1.74%)
:arrow_down:

...corp/pinpoint/rpc/stream/StreamChannelManager.java
70.68% <0%> (-1.73%)
:arrow_down:

...m/navercorp/pinpoint/profiler/AgentInfoSender.java
75.67% <0%> (-0.91%)
:arrow_down:

...point/rpc/client/DefaultPinpointClientHandler.java
72.61% <0%> (+0.31%)
:arrow_up:

...om/navercorp/pinpoint/rpc/codec/PacketDecoder.java
63.82% <0%> (+2.12%)
:arrow_up:

...navercorp/pinpoint/rpc/common/SocketStateCode.java
85.36% <0%> (+2.43%)
:arrow_up:

...ofiler/sender/StandbySpanStreamDataSendWorker.java
83.58% <0%> (+2.98%)
:arrow_up:

... and 3 more

Continue to review full report at Codecov.

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


Improve Footer Layout and Color for a More Professional and Attractive Appearance

Prerequisites

[X] I have searched for duplicate or closed feature requests
[X] I have read the contributing guidelines

Proposal
The current footer design in Bootstrap is quite functional but lacks a modern and professional appeal. I would like to propose a change to the footer layout and its color scheme to make it more visually appealing and aligned with modern web design trends.
Proposal: Here are some suggested improvements to the footer layout and design:
1)Color Scheme Update: Use a more vibrant and modern color palette to give the footer a sleek and professional look.
2)Layout Reorganization: Enhance the structure of the footer by organizing content into columns and using responsive design techniques to ensure that the footer adapts well to all screen sizes.
3)Spacing and Alignment: Increase the spacing between sections for better readability and use consistent alignment for a polished finish.
Motivation and context
The current footer feels somewhat outdated and can be improved to align with modern design principles. A more visually appealing footer will help improve user experience and maintain a cohesive look throughout the Bootstrap framework.

Closing the issue as you provided a PR directly

Thanks for the feedback! That makes sense—I'll hold off on any code changes until we hear back from @mdo regarding the design. I appreciate your input on the light version too, and I agree that toning down the colors might help. Once we get clarity on the design direction, I can make adjustments to the logo and text as well.


Ref Guide: Miscellaneous cleanups

Fixes SOLR-15230
removes duplicated words ("the the", etc.)
heading levels out of order & casing
typos

LGTM


docs(readme): add dependency badge

This PR adds the requires.io badge.

:tada: This PR is included in version 1.0.0 :tada:
The release is available on GitHub release
Your semantic-release bot :package::rocket:


Hide openInPortal command from palette

This command now only handles opening deployments in the portal, so I think it's ok to remove from the palette.
Alternatively, we could rebrand this command as "Open Deployment in Portal", but we don't have any other commands like that so I felt it wasn't necessary.

Note: pushed an extra commit up after Brandon approved, reverted to the correct commit (8cd963d)


Fakeredis 1.7.4 not compatible with Python 3.10

Describe the bug
Unable to install fakeredis 1.74 with Python 3.10
To Reproduce
Steps to reproduce the behavior:

Install Python 3.10 with openssl-1.1.1o
Pip install fakeredis
Error received as below

  Running setup.py install for hiredis: started
  Running setup.py install for hiredis: finished with status 'error'
  error: subprocess-exited-with-error

  × Running setup.py install for hiredis did not run successfully.
  │ exit code: 1
  ╰─> [32 lines of output]
      /tmp/pip-install-_d6d1y9g/hiredis_a71de6dff6b144529f910eb349fefc27/setup.py:7: DeprecationWarning: the imp module is deprecated in favour of importlib and slated for removal in Python 3.12; see the module's documentation for alternative uses
        import sys, imp, os, glob, io
      /usr/local/lib/python3.10/site-packages/setuptools/dist.py:717: UserWarning: Usage of dash-separated 'description-file' will not be supported in future versions. Please use the underscore name 'description_file' instead
        warnings.warn(
      running install
      running build
      running build_py
      creating build
      creating build/lib.linux-x86_64-3.10
      creating build/lib.linux-x86_64-3.10/hiredis
      copying hiredis/__init__.py -> build/lib.linux-x86_64-3.10/hiredis
      copying hiredis/version.py -> build/lib.linux-x86_64-3.10/hiredis
      copying hiredis/hiredis.pyi -> build/lib.linux-x86_64-3.10/hiredis
      copying hiredis/py.typed -> build/lib.linux-x86_64-3.10/hiredis
      warning: build_py: byte-compiling is disabled, skipping.

      running build_ext
      building 'hiredis.hiredis' extension
      creating build/temp.linux-x86_64-3.10
      creating build/temp.linux-x86_64-3.10/src
      creating build/temp.linux-x86_64-3.10/vendor
      creating build/temp.linux-x86_64-3.10/vendor/hiredis
      gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -fPIC -Ivendor -I/usr/local/include/python3.10 -c src/hiredis.c -o build/temp.linux-x86_64-3.10/src/hiredis.o
      gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -fPIC -Ivendor -I/usr/local/include/python3.10 -c src/reader.c -o build/temp.linux-x86_64-3.10/src/reader.o
      gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -fPIC -Ivendor -I/usr/local/include/python3.10 -c vendor/hiredis/alloc.c -o build/temp.linux-x86_64-3.10/vendor/hiredis/alloc.o
      gcc -pthread -Wno-unused-result -Wsign-compare -DNDEBUG -g -fwrapv -O3 -Wall -fPIC -Ivendor -I/usr/local/include/python3.10 -c vendor/hiredis/read.c -o build/temp.linux-x86_64-3.10/vendor/hiredis/read.o
      vendor/hiredis/read.c: In function 'redisReaderFree':
      vendor/hiredis/read.c:646:9: error: 'for' loop initial declarations are only allowed in C99 mode
               for (int i = 0; i < r->tasks; i++) {
               ^
      vendor/hiredis/read.c:646:9: note: use option -std=c99 or -std=gnu99 to compile your code
      error: command '/usr/bin/gcc' failed with exit code 1
      [end of output]

  note: This error originates from a subprocess, and is likely not a problem with pip.
error: legacy-install-failure

× Encountered error while trying to install package.
╰─> hiredis

note: This is an issue with the package mentioned above, not pip.
hint: See above for output from the failure.

Expected behavior
Clean install
Desktop (please complete the following information):

OS: CentOS Linux release 7.9.2009 (Core)
python version: 3.10.4
redis-py version: 4.2.2

It looks like you are installing hiredis and not fakeredis
What command are you using to install fakeredis?
Running pip install fakeredis works fine with python3.10

@cunla that's true.
I had earlier mistook hiredis as a dependency for fakeredis.
We can close this.
Thank you!


[Image pull] - Report all the hosts where the image pull is being attempted and the final status of the image pull.

Server version -Build from master
Currently rancher pull , does not report all the hosts to which the image pull is attempted.
I see a the status for a subset of hosts being reported and is also a transitional (pulling) message .
In this case , pull was actually done for 3 hosts but only 1 pull was reported:
root@sangee01:/home/sangeethahariharan1/rancher-compose-v0.4.0-rc1# ./rancher-compose -f dc2.yml pull
INFO[0001] Pulling sangeetha/testupgrade on sangeemaster-10acre-1

We should report the final pull status for all the attempted host.
In case of cached option , it would be good to  be able to provide a list of hosts where the image pull was not done.

Tested with:
Server version - V0.38.0-rc2
Rancher compose version - rancher-compose-v0.4.0-rc3
We now report all the hosts where the images get pulled and when the image pull is actually done:
INFO[0001] Pulling sangeetha/testclient on sangee38rc2again-10acre-1
INFO[0001] Pulling sangeetha/testclient on sangee38rc2again-10acre-3
INFO[0002] Finished pulling sangeetha/testclient on sangee38rc2again-10acre-3
INFO[0002] Finished pulling sangeetha/testclient on sangee38rc2again-10acre-1

Reopening the issue to fix the logging for use case where --cached option is used.
Even when images were not pulled on host (which did not have images ti begin with) , rancher-compose logs report the following :
INFO[0002] Finished sangeetha/testclient on sangee38rc2again-10acre-1
We should be able to indicate that image was not actually pulled in this case .


database hosting

Sarching for a solution

https://forums.couchbase.com/t/recommended-hosting/7567/3?u=adriatic
email to Jeff Barr (Amazon's chief evangelist)

Experimentation with some vendors
1. Azure
2. Amazon EWS
3. MongoLabs

Monterey database independent API

[ ] @JeroenVinke define the API
[ ] Implement the service layer using https://github.com/SpoonX/aurelia-api


Central info file

Create support for a central info file, where all current and future settings are stored about the Repo which is being installed.
This needs to be merged correctly with #25, which already starts implementing this.
First #25 need to read the version, then one might need to read the same file in a different branch

@ChristophLHR I would suggest to resolve this issue before you continue working on #25. As this is a much smaller change which may be used somewhere else as well, whereas #25 does much more then just creating an info file.
The way I understand it is, we change the current info file, which is files.txt, to something like infofile.lua to support more than just a list of files. So every library should have the infofile.lua with an entry files containing a list of file names, making up for the, then deleted, files.txt.
Also if no infofile.lua is found, we should still look for files.txt until every lib is updated.
It would be best to create an issue for the update in every repository this affects.
After resolving this issue, please make sure to update the documentation. I'm, not sure if this is the only place we mentioned it, but it's definitely part of the naming convention.