Exercism v3 launches on Sept 1st 2021. Learn more! ๐Ÿš€๐Ÿš€๐Ÿš€
Avatar of rootulp

rootulp's solution

to Phone Number in the Python Track

Published at Jul 13 2018 · 0 comments
Instructions
Test suite
Solution

Note:

This solution was written on an old version of Exercism. The tests below might not correspond to the solution code, and the exercise may have changed since this code was written.

Clean up user-entered phone numbers so that they can be sent SMS messages.

The North American Numbering Plan (NANP) is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda. All NANP-countries share the same international country code: 1.

NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as area code, followed by a seven-digit local number. The first three digits of the local number represent the exchange code, followed by the unique four-digit number which is the subscriber number.

The format is usually represented as

(NXX)-NXX-XXXX

where N is any digit from 2 through 9 and X is any digit from 0 through 9.

Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code (1) if present.

For example, the inputs

  • +1 (613)-995-0253
  • 613-995-0253
  • 1 613 995 0253
  • 613.995.0253

should all produce the output

6139950253

Note: As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.

Exception messages

Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include a message.

To raise a message with an exception, just write it as an argument to the exception type. For example, instead of raise Exception, you should write:

raise Exception("Meaningful message indicating the source of the error")

Running the tests

To run the tests, run the appropriate command below (why they are different):

  • Python 2.7: py.test phone_number_test.py
  • Python 3.4+: pytest phone_number_test.py

Alternatively, you can tell Python to run the pytest module (allowing the same command to be used regardless of Python version): python -m pytest phone_number_test.py

Common pytest options

  • -v : enable verbose output
  • -x : stop running tests on first failure
  • --ff : run failures from previous test before running other test cases

For other options, see python -m pytest -h

Submitting Exercises

Note that, when trying to submit an exercise, make sure the solution is in the $EXERCISM_WORKSPACE/python/phone-number directory.

You can find your Exercism workspace by running exercism debug and looking for the line that starts with Workspace.

For more detailed information about running tests, code style and linting, please see the help page.

Source

Event Manager by JumpstartLab http://tutorials.jumpstartlab.com/projects/eventmanager.html

Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

phone_number_test.py

import unittest

from phone_number import Phone


# Tests adapted from `problem-specifications//canonical-data.json` @ v1.4.0

class PhoneNumberTest(unittest.TestCase):
    def test_cleans_number(self):
        number = Phone("(223) 456-7890").number
        self.assertEqual(number, "2234567890")

    def test_cleans_number_with_dots(self):
        number = Phone("223.456.7890").number
        self.assertEqual(number, "2234567890")

    def test_cleans_number_with_multiple_spaces(self):
        number = Phone("223 456   7890   ").number
        self.assertEqual(number, "2234567890")

    def test_invalid_when_9_digits(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("123456789")

    def test_invalid_when_11_digits_and_first_not_1(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("22234567890")

    def test_valid_when_11_digits_and_first_is_1(self):
        number = Phone("12234567890").number
        self.assertEqual(number, "2234567890")

    def test_valid_when_11_digits_and_first_is_1_with_punctuation(self):
        number = Phone("+1 (223) 456-7890").number
        self.assertEqual(number, "2234567890")

    def test_invalid_when_more_than_11_digits(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("321234567890")

    def test_invalid_with_letters(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("123-abc-7890")

    def test_invalid_with_punctuation(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("123-@:!-7890")

    def test_invalid_if_area_code_starts_with_0(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("(023) 456-7890")

    def test_invalid_if_area_code_starts_with_1(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("(123) 456-7890")

    def test_invalid_if_exchange_code_starts_with_0(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("(223) 056-7890")

    def test_invalid_if_exchange_code_starts_with_1(self):
        with self.assertRaisesWithMessage(ValueError):
            Phone("(223) 156-7890")

    # Track specific tests
    def test_area_code(self):
        number = Phone("2234567890")
        self.assertEqual(number.area_code, "223")

    def test_pretty_print(self):
        number = Phone("2234567890")
        self.assertEqual(number.pretty(), "(223) 456-7890")

    def test_pretty_print_with_full_us_phone_number(self):
        number = Phone("12234567890")
        self.assertEqual(number.pretty(), "(223) 456-7890")

    # Utility functions
    def setUp(self):
        try:
            self.assertRaisesRegex
        except AttributeError:
            self.assertRaisesRegex = self.assertRaisesRegexp

    def assertRaisesWithMessage(self, exception):
        return self.assertRaisesRegex(exception, r".+")


if __name__ == '__main__':
    unittest.main()
class Phone:

    INVALID_NUM = "0" * 10
    AREA_CODE_END = 3
    EXCHANGE_CODE_END = 6

    def __init__(self, inp):
        self.number = self.number(inp)

    def number(self, inp):
        cleaned = self.strip(inp)
        if self.valid_11_digits(cleaned):
            return cleaned[1:]
        elif self.valid_10_digits(cleaned):
            return cleaned
        return self.INVALID_NUM

    def area_code(self):
        return self.number[:self.AREA_CODE_END]

    def exchange_code(self):
        return self.number[self.AREA_CODE_END:self.EXCHANGE_CODE_END]

    def subscriber_code(self):
        return self.number[self.EXCHANGE_CODE_END:]

    def pretty(self):
        return "({}) {}-{}".format(self.area_code(), self.exchange_code(),
                                   self.subscriber_code())

    @staticmethod
    def valid_11_digits(inp):
        return len(inp) == 11 and inp.startswith("1")

    @staticmethod
    def valid_10_digits(inp):
        return len(inp) == 10

    @staticmethod
    def strip(inp):
        return ''.join(char for char in inp if char.isdigit())

Community comments

Find this solution interesting? Ask the author a question to learn more.

What can you learn from this solution?

A huge amount can be learned from reading other peopleโ€™s code. This is why we wanted to give exercism users the option of making their solutions public.

Here are some questions to help you reflect on this solution and learn the most from it.

  • What compromises have been made?
  • Are there new concepts here that you could read more about to improve your understanding?