Port concept exercise strings from C#

* Add scaffold files/directories.

* Add instructions and introduction.

* Add hints with some links.

* Add config files.

* Update description to use loglines module, and add prerequisite.

* Add Python specific files, start on implementation.

* Update tests.

* Add more tests.

* Update docs with text around links.

* Update tests with reformat test, and fix example import from testing.

* Add third function, reformat.

* Move an item into after.md, and add Joel Spolsky's blog post as reference for strings.

* Add design notes.

* Add reference types note.

* Alternate solution not using regex groups, just split.

* Update languages/exercises/concept/strings/.docs/after.md

Co-Authored-By: Erik Schierboom <[email protected]>

* Update loglines test
 - updated filename to match tooling
 - import functions, not module
 - use testcase.assertEqual instead of assert

* Use an example that does not use Regex.

* Better regex for regex-based solution.

* Update .docs and .meta.

* Change strings-methods to strings-basic, for consistency and to better reflect the purpose of the exercise.

Co-Authored-By: Erik Schierboom <[email protected]>

* Add more information to introduction.md. TODO: add links.

* Add extra context for hints.md.

* Add UUID to strings exercise config.

* Simpify initial description of strings.

Co-Authored-By: Erik Schierboom <[email protected]>

* Add more context around various string methods.

* Remove After header.

Co-Authored-By: Erik Schierboom <[email protected]>

* Use link for Joel on Software post.

Co-Authored-By: Erik Schierboom <[email protected]>

* Cleanup header formatting, use actual link.

Co-Authored-By: Erik Schierboom <[email protected]>

* Change method -> function.

Co-Authored-By: Erik Schierboom <[email protected]>

* Name prerequisite with -basic suffix.

* Leave a bit to the imagination for strings hints.

* Move example.py into .meta folder per instructions.

* Update links for after and hints.md

* Update hints.md w.r.t. join() and fix link.

* Add missing implementation link.

* Single spacing between functions.

* Remove leading whitespace in

* Fix missing backticks and make Python examples read as if inside a REPL.

* Update from review feedback.

* Update languages/exercises/concept/strings/.docs/hints.md

Co-Authored-By: Erik Schierboom <[email protected]>

* Update languages/exercises/concept/strings/.docs/instructions.md

Co-Authored-By: Erik Schierboom <[email protected]>

* Update languages/exercises/concept/strings/.docs/introduction.md

Co-Authored-By: Erik Schierboom <[email protected]>

* Update languages/exercises/concept/strings/.docs/hints.md

Co-Authored-By: Erik Schierboom <[email protected]>

* Link to python3 latest docs.

* Use named capture groups in regex for solution.

* Add extra test for capitalized words.

* Use msg parameter for assert statements in test.

* Use dashed style UUID.

* Rename test and clarify exactly what is being tested.

Co-authored-by: Erik Schierboom <[email protected]>

Author: 2 people

exercises/concept/strings/.docs/after.md

@@ -0,0 +1,13 @@
+Python strings can be powerful. At their core, a string is an iterable of Unicode code points. There is no separate "character" type in Python. For a deep dive on what information a string is encoding (or, "how does the computer know how to translate zeroes and ones into letters?"), [this blog post is enduringly helpful][joel-on-text].
+
+As a Python data type, strings can be manipulated by various methods, split into letters, used to join a list of strings into one string, amongst other things. The simplest way to create a string is by literally delimiting with `"` or `'` (e.g. `mystring = "astring"`); however, strings can also be written across multiple lines by using triple quotes (`"""`), or written to be used as a format string, like this: `f"{variable_will_be_interpolated_here}"`.
+
+New strings can be created by concatenating other strings, using the `+` operator, or by using `.join()`. The `.format()` method or the format string syntax shown above are the most common way to interpolate strings. All of these methods return a new instance of a string, since a string itself is immutable.
+
+### More about Python logging
+
+Python has a useful [built-in logging library][logging-library], aptly named `logging`. It handles cases similar
+to the ones you just finished working on, and many more. It's very often used in projects, and is worthwhile to know.
+
+[joel-on-text]: https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/
+[logging-library]: https://docs.python.org/3.8/library/logging.html

exercises/concept/strings/.docs/hints.md

@@ -0,0 +1,26 @@
+### General
+
+- The [Python documentation for `str`][python-str-doc] has an overview of the Python `str` type.
+
+### 1. Get message from a log line
+
+ - Strings in Python have [lots of convenient instance methods][str-type-methods] for cleaning, splitting, manipulating, and creating new strings. Extracting values from a string could be done by splitting it based on a substring, for example.
+
+### 2. Get log level from a log line
+
+ - Strings also have methods that help convert letters from lower to uppercase and vice-versa.
+
+### 3. Reformat a log line
+
+Strings are immutable, but can be combined together to make new strings, or have elements replaced. This goal can be accomplished by using string methods, or operators like `+` or `+=` (which are overloaded to work with strings).
+Python also has a concept of string formatting, like many other languages.
+
+ - The [`str.join()`][str-join] method is useful to join an iterable of strings into one string by interspersing them with a common value, e.g. `":".join("abcde")` would create `"a:b:c:d:e"`.
+ - [`str.format()`][str-format] is an idiomatic way to do string interpolation in Python (inserting one or more string value(s) into another).
+ - [Format strings][format-str] are another convenient way to interpolate values into a string. This strategy is particularly useful when more than one named variable needs to be inserted into a final output.
+
+ [python-str-doc]: https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str
+ [str-type-methods]: https://docs.python.org/3/library/stdtypes.html#str
+ [str-join]: https://docs.python.org/3/library/stdtypes.html#str.join
+ [str-format]: https://docs.python.org/3/library/stdtypes.html#str.format
+ [format-str]: https://docs.python.org/3/library/string.html#formatstrings

exercises/concept/strings/.docs/instructions.md

@@ -0,0 +1,45 @@
+In this exercise you'll be processing log-lines.
+
+Each log line is a string formatted as follows: `"[<LEVEL>]: <MESSAGE>"`.
+
+There are three different log levels:
+
+- `INFO`
+- `WARNING`
+- `ERROR`
+
+You have three tasks, each of which will take a log line and ask you to do something with it.
+
+### 1. Extract a message from a log line
+
+Implement a function to return a log line's message:
+
+```python
+>>> extract_message("[ERROR]: Invalid operation")
+'Invalid operation'
+```
+
+The message should be trimmed of any whitespace.
+
+```python
+>>> extract_message("[ERROR]: Invalid operation.\t\n")
+'Invalid operation.'
+```
+
+### 2. Change a message's loglevel.
+
+Implement a function that replaces a log line's current log level with a new one:
+
+```python
+>>> change_log_level("[INFO]: Fatal Error.", "ERROR")
+'[ERROR]: Fatal Error.'
+```
+
+### 3. Reformat a log line
+
+Implement a function that reformats the log line, putting the message first and the log level after it in parentheses:
+
+```python
+>>> reformat("[INFO]: Operation completed")
+'Operation completed (info)'
+```

exercises/concept/strings/.docs/introduction.md

@@ -0,0 +1,3 @@
+A `str` typed object in Python is an immutable sequence of Unicode code points. This could include letters, numbers, punctuation, etc. To manipulate strings, Python provides string methods that can transform a string into other types, create new strings based on method arguments, or return information about the string. Strings can be concatenated with `+`.
+
+Immutability means that a string's value doesn't change; methods that appear to modify a string actually return a new instance of `str`.

exercises/concept/strings/.meta/config.json

@@ -0,0 +1,8 @@
+{
+  "contributors": [
+    {
+      "github_username": "aldraco",
+      "exercism_username": "aldraco"
+    }
+  ]
+}

exercises/concept/strings/.meta/design.md

@@ -0,0 +1,39 @@
+# Design
+
+## Goal
+
+The goal of this exercise is to teach the student about Python strings, and familiarize them with string manipulation in Python.
+
+## Things to teach
+
+ - Know that Python has a `str` type.
+ - Know how to find items in a string.
+ - Know how to manipulate strings to create new strings.
+ - Familiarize one's self with string instance methods in Python.
+ - Learn about string formatting.
+
+## Things not to teach
+
+- Regex: `regex` is a useful tool for a solution, but isn't required.
+- Iteration: Although strings are iterable, this is not the focus of this exercise.
+
+## Concepts
+
+The Concepts this exercise unlocks are:
+
+ - `strings-basic`: know about `str` type in Python, know some basic methods, know about formatting.
+
+## Prerequisites
+
+ - `functions`: The student should be familiar with creating functions.
+
+## Representer
+
+This exercise does not require any logic to be added to the [representer][representer]
+
+## Analyzer
+
+This exercise does not require any logic to be added to the [analyzer][analyzer].
+
+[analyzer]: https://github.com/exercism/python-analyzer
+[representer]: https://github.com/exercism/python-representer

exercises/concept/strings/.meta/example.py

@@ -0,0 +1,27 @@
+import re
+
+LOGLINE_RE = r"\[(?P<level>INFO|ERROR|WARN)\] (?P<msg>.*)"
+
+
+def _extract_pieces(message):
+    pieces = re.search(LOGLINE_RE, message)
+    return pieces.group("level"), pieces.group("msg")
+
+def _extract_pieces_no_regex_groups(message):
+    words = [word for word in re.split("[\s\[\]]", message) if word]
+    return words[0], " ".join(words[1:])
+
+def _extract_pieces_no_regex(message):
+    words = [word for word in message.strip().replace("]", "[").split("[") if word]
+    return words[0], words[1].strip()
+
+def change_log_level(message, new_loglevel):
+    """Change loglevel of message to new_loglevel."""
+    return f"[{new_loglevel}] {extract_message(message)}"
+
+def extract_message(message):
+    return _extract_pieces_no_regex(message)[1]
+
+def reformat(message):
+    loglevel, msg = _extract_pieces_no_regex_groups(message)
+    return f"{msg} ({loglevel.lower()})"

exercises/concept/strings/loglines.py

@@ -0,0 +1,8 @@
+def change_log_level():
+    pass
+
+def extract_message():
+    pass
+
+def reformat():
+    pass

exercises/concept/strings/loglines_test.py

@@ -0,0 +1,53 @@
+import unittest
+from loglines import extract_message, change_log_level, reformat
+
+
+class TestLogLines(unittest.TestCase):
+    def test_message(self):
+        self.assertEqual(
+            extract_message("[INFO] Hello there."),
+            "Hello there.",
+            msg="Should correctly extract a basic message.",
+        )
+
+    def test_message_with_punctuation(self):
+        self.assertEqual(
+            extract_message("[WARN] File not found: exercism_practice.py"),
+            "File not found: exercism_practice.py",
+            msg="Should preserve punctuation and whitespace from original message.",
+        )
+
+    def test_level_word_remains_in_message(self):
+        self.assertEqual(
+            extract_message("[ERROR] Error while serializing data."),
+            "Error while serializing data.",
+            msg="Should preserve a loglevel word that is actually part of the message.",
+        )
+
+    def test_change_loglevel(self):
+        self.assertEqual(
+            change_log_level("[ERROR] No configs found, but not a big deal.", "INFO"),
+            "[INFO] No configs found, but not a big deal.",
+            msg="Should replace the loglevel.",
+        )
+
+    def test_change_loglevel_with_loglevel_in_message(self):
+        self.assertEqual(
+            change_log_level("[WARN] Warning: file does not exist.", "INFO"),
+            "[INFO] Warning: file does not exist.",
+            msg="Should not replace loglevel names that are part of the message.",
+        )
+
+    def test_reformat(self):
+        self.assertEqual(
+            reformat("[WARN] Warning: file not found."),
+            "Warning: file not found. (warn)",
+            msg="Should reformat with lowercase loglevel. ",
+        )
+
+    def test_capture_message_when_contains_loglevel_string(self):
+        self.assertEqual(
+            extract_message("[WARN] Warning: file not found. Will WARN once."),
+            "Warning: file not found. Will WARN once.",
+            msg="Should extract loglevel inside brackets, not from messsage, even if message contains something that looks like a loglevel.",
+        )