db_uname,george
db_password,password1
data_query,"SELECT this, that FROM mytable WHERE col = 5"

class Config:
    """ class for producing config instances ... [PLEASE DESCRIBE FURTHER] """

    def __init__(self, filename):
        """ constructor ... [PLEASE DESCRIBE FURTHER] """

Exception raising. raise an exception for the following condition

How to detect a corrupted file? The data file should have two values per line. If your program sees that there are not exactly two values in a line, it should raise a ValueError exception with a custom message (DO NOT print the error message! DO NOT exit from the method!). corrupted.csv has been provided as a file that is not in proper format. PLEASE NOTE you must NEVER print() an error message from a function or method. Use raise and allow the exception to occur. print() statements can easily be missed in the user's output. PLEASE NOTE you must NEVER exit() from a library function or method. It should not be the responsibility of a utility class to exit a program that imports or uses it. For added challenge, inform the user on what line too few or too many values was found

Remember, NEVER print() OR exit() from a function or method in a module or class. To assist in organizing the program, I recommend the following methods:

• def __init__(self, filename):

  set the self.filename and self.format attributes, and call self.read_csv_file() (see below) to retrieve a dict built from the file. Store this dict in the instance as self.params



• def read_csv_file(self):

  open self.filename, read the file and build a dict of key/value pairs, then return the dict. (Note: ideally, this would be a @staticmethod since as envisioned here it does not use self or cls (the class instance)



• def get(self, key, default=None):

  read a value from the self.params dict and return it. If the key can't be found, it will return the default



• def __str__(self):

  return a string that indicates how the instance was constructed, i.e. Config('pconfig.csv')
  (consider self.__class__.__str__)

In order to emulate the behavior of a dict, your __getitem__() must raise a KeyError exception if the key can't be found. In other words, __getitem__() will behave like get(), but without the default= argument funtionality that get() employs. It's worth reiterating that functions and methods of classes and modules must never print error messages! They must not call exit(). Instead, they use the 'raise' statement to raise exceptions to signal errors.

If you inherit from dict, then you can use the instance itself as the dict rather than using self.params. Reading keys and values from the instance: inheriting from dict means you can inherit from several dict "read" methods, which do not need to be implemented: reading a key based on a value (__getitem__(), looping through a dict keys, methods .keys() and .values(), etc.

def __getitem__(self, key):
    value = self[key]          # calls self.__getitem__(key)

The above method uses item assignment (value = self[key]), which again calls __getitem__(self, key), which again calls __getitem__(self, key)...

RecursionError: maximum recursion depth exceeded

This means that Python stopped after it observed 100 consecutive calls to __getitem__().

def __getitem__(self, key):
    dict.__getitem__(self, key)

__init__(self, *args, **kwargs) Because it is possible to initialize a dict with argument (usually a list of key/value pairs), to fully implement a dict-like object you would need to create an __init__() method that a) receives "any" arguments (similar to what was done in the decorator assignment) and then passes those arguments to super().__init__(). Contact me if you need clarification on this feature.

Allow the configuration file to be in any of 3 formats:

• .csv
• .json
• .ini (simple key=value lines, see below)

The program uses the extension (stored in the .format attribute) to determine how to parse the data. (sample config files pconfig.csv, pconfig.json and pconfig.ini are provided.)

data_query=SELECT this, that FROM mytable WHERE col = 5
db_uname=george
db_password=password1
email_from=joe@wilson.com

#obj = Config('pconfig.xxx')          # ValueError:  file type "xxx" not recognized

If the extension of the file is not csv, json or ini, your code should raise a ValueError exception with the above message, naming the extension and explaining that the file type is not recognized. Detecting corruption - I have provided corrupted.ini and corrupted.json, each of which cannot be parsed properly. The .ini file has the same issue as the corrupted .csv file: a missing '=' delimiter. So the corruption can be detected in a way similar to that of the .csv file. The corruption in the .json file, however, must be detected in a different way: if the JSON parser used in json.load detects a missing structural character (for example, if a quotation, colon or brace is missing) it will raise a json.decoder.JSONDecodeError exception. (The exception name is written differently because it is defined in the json module.) First, try to read the corrupted.json file and note that the exception is raised. Next, wrap the line that triggered the exception in a try: block, and follow with an except block that names the above exception (never use except: or except Exception: because it traps any exception). Finally, raise your own ValueError exception with message as with csv.

This is done principally through the inspect module (inspect.getmembers(), inspect.signature(), the built-in callable() function and the class or method's .__doc__ attribute. See slides or discussion for details.

 __class__
    type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type

__delattr__(self, name, /)
    Implement delattr(self, name).
... continues ...

...
getvalue
        given a key, return the value found
        in the object

read_csv_file
        open the config file for reading and
        read the file contents into a dict
        in the object

... continues ...

...
getvalue(self, key)
        given a key, return the value found
        in the object


read_csv_file(self)
        open the config file for reading and
        read the file contents into a dict
        in the object

... continues ...

Note that one callable attribute, class, will fail with ValueError if you attempt to call inspect.signature(). Trap this exception and skip over signature for this attribute.

The __init__ constructor also accepts an optional argument writeonce=True, to indicate if attributes can be set only once. (Use hasattr() to see if the object already holds the attribute.)

__init__ will set two attributes: _type (the initialized type) and _writeonce (indicating if attributes can be set more than once). These attributes start with a single underscore because they are "non-public" attributes -- see variable naming conventions.) The class implements the __setattr__ method to validate attributes before setting. It uses internal instance attributes _type to validate the type and _writeonce to disallow overwriting (if applicable). The method also makes sure that these internal attributes cannot be overwritten. However, beware setting attributes on the instance directly! Remember that anytime you set an attribute on self, Python will attempt to call __setattr__, calling the method again, potentially causing infinite recursion (you would see the error Maximum recursion depth reached). Instead, call the parent class' __setattr__ method: object.__setattr__(self, attrname, attrval), where attrname and attrval are the attribute name and value. We are also seeing an issue where Python seems to not be able to see an attribute that was set on the object. The class also implements two methods: as_list() returns the attribute values as a list, and as_dict() returns the attribute dict (however, make sure the return values don't contain the _type or _writeonce attributes).

Extra credit: allow the type argument 'number' (passed as a string, not an object type). In order to validate, use isinstance() on the parent type: isinstance(var, numbers.Number) (imported from the numbers module). This will allow the user to assign any number (including types float, int or long).