You can use

const text = 'is:"browser" browser: "chrome 11.11 V" node: error type:"Error"';
const re = /(\w+):\s*(?:"([^"]*)"|(\S+))/g;
let dict = {}, m;
while(m = re.exec(text)) {
  dict[m[1]]=(m[3] || m[2]);
}
console.log(dict);

// Or just get all matches:
console.log(text.match(re))

See the regex demo. Details:

• (\w+) - Group 1: one or more word chars
• : - a colon
• \s* - zero or more whitespaces
• (?:"([^"]*)"|(\S+)) - either of
  • "([^"]*)" - ", 0+ non-commas (captured in Group 2), "
  • | - or
  • (\S+) - Group 3: one or more non-whitespaces chars.

You usually want a zero-width word boundary \b on either end of the regex, to avoid matching things like 1a:1a.

There's no need to capture [a-z]+ since you are throwing it away.

You can use lookbehind (?<=…) assertions to require a match to be preceded by whatever, without including the whatever in the match result. This means no need for capturing parenthesis, only the integer is included in the match, and the final map is simply _.toInt. Variable-width lookbehind was introduced in Java 9; older versions have only fixed-width lookbehind.

Finally, removing the variable makes braces unnecessary.

def numericValues(text: String): List[Int] = """(?<=\b[a-z]+\s*:\s*)\d+\b""".r.findAllIn(text).toList.map(_.toInt)

With only fixed-width lookbehind, you could postprocess the matches to remove non-numerics:

….map(_.replaceAll("[^0-9]", "").toInt)

Or, more idiomatically and less hacky, just capture the digits and extract the capture groups:

"""\b[a-z]+\s*:\s*(\d+)\b""".r.findAllIn(text).matchData.toList.map(_.group(1).toInt)

@acfrancis explanation is correct, on the other hand you can try the following:

/(\w+)=([^\s]+)/g

This matches the <key> using (\w+) as in you original expression, but then it matches the value using ([^\s]+) which consumes one or more characters that are not white spaces.

Regex101 Demo

Try with a lookahead:

(\b\w+)=(.*?(?=\s\w+=|$))

As a Java String:

"(\\b\\w+)=(.*?(?=\\s\\w+=|$))"

Test at regex101.com; Test at regexplanet (click on "Java")

Assuming that you either have a word like ActiveList or something in bewteen <> you could is this reg exp:

\s*(\w+)\s*=\s*(\w+|<.*?>)\s*

First group will capture the attr name and second will capture a word (ActiveList) or anything between <> like <Resource URI\="/All Active Lists/_CAL/Infrastructure/Active Directory/Inventory/Inventory - By User (Bobo)" ID\="CCCsSSdDDD\=\="/>

Then, you just need to iterate over results and join them with =:

>>> for attr, value in re.findall("\s*(\w+)\s*=\s*(\w+|<.*?>)\s*",text):
        print "%s=%s" % (attr, value)

attr1=ActiveList
attr2=<Resource URI\="/All Active Lists/_CAL/Infrastructure/Active Directory/Inventory/Inventory - By User (Dedd)" ID\="DSdddCcSSS\=\="/>
attr3=ActiveLis
attr4=ActiveList
attr5=<Resource URI\="/All Active Lists/_CAL/Infrastructure/Active Directory/Inventory/Inventory - By User (Bobo)" ID\="CCCsSSdDDD\=\="/>
attr6=ActiveLis

You have a few ways to do this. First, since you said your key-value pairs are embedded in a larger email, you need to extract them. You can do that with this regex, which checks for a line starting with a word and an equals sign:

import re

text = " ... Full email text ... "
dataPoints = re.search(r"^\w*=.*$", text, re.MULTILINE).group(0)

Then you need to create your dictionary.

Option 1: Simplest

Use the following regex find:

result = dict(re.findall(r'(\w*)=(\".*?\"|\S*)', dataPoints))

Regex demo

Option 2: Typical split

Follow the typical method for this problem: split the various key-value combinations into a list, and then split each combination into separate keys and values. However, since your key-value pairs are separated by spaces rather than semicolons, ampersands, or something similar, and some of your values have spaces in them, we can't simply split by spaces. That means we need to use a regex lookahead for this to work properly:

regexSplit = dict([i.split("=") for i in re.split(r"\s(?=\w+=)", dataPoints)])

Option 3: No regex

If you want to avoid using regex altogether for whatever reason, you can use the following, which splits on equals signs and then recombines the keys and values into the proper arrangement for creating a dictionary:

allSplits = dataPoints.split("=")
splitList = [allSplits[0]] + [i for a in allSplits[1:-1] 
    for i in a.rsplit(" ", 1)] + [allSplits[-1]]

splitDict = dict(zip(splitList[::2], splitList[1::2]))

The code above assumes your dictionary will end up with at least 2 items.

Demo for all 3 options