fixes #334

Author: jph00

README.md

@@ -2,7 +2,7 @@
 > Python goodies to make your coding faster, easier, and more maintainable
 
 
-Python is a powerful, dynamic language. Rather than bake everything into the language, it lets the programmer customize it to make it work for them. `fastcore` uses this flexibility to add to Python features inspired by other languages we've loved, like multiple dispatch from Julia, mixins from Ruby, and currying, binding, and more from Haskell. It also adds some "missing features" and cleans up some rough edges in the Python standard library, such as simplifying parallel processing, and bringing ideas from NumPy over to Python's `list` type.
+Python is a powerful, dynamic language. Rather than bake everything into the language, it lets the programmer customize it to make it work for them. `fastcore` uses this flexibility to add to Python features inspired by other languages we've loved, like multiple dispatch from Julia, mixins from Ruby, and currying, binding, and more from Haskell. It also adds some "missing features" and clean up some rough edges in the Python standard library, such as simplifying parallel processing, and bringing ideas from NumPy over to Python's `list` type.
 
 ## Installing
 
@@ -27,7 +27,7 @@ Here's a (somewhat) quick tour of a few higlights, showing examples from each of
 
 All fast.ai projects, including this one, are built with [nbdev](https://nbdev.fast.ai), which is a full literate programming environment built on Jupyter Notebooks. That means that every piece of documentation, including the page you're reading now, can be accessed as interactive Jupyter notebooks. In fact, you can even grab a link directly to a notebook running interactively on Google Colab - if you want to follow along with this tour, click the link below, or click the badge at the top of the page:
 
-```python
+```
 colab_link('index')
 ```
 
@@ -37,7 +37,7 @@ colab_link('index')
 
 The full docs are available at [fastcore.fast.ai](https://fastcore.fast.ai). The code in the examples and in all fast.ai libraries follow the [fast.ai style guide](https://docs.fast.ai/dev/style.html). In order to support interactive programming, all fast.ai libraries are designed to allow for `import *` to be used safely, particular by ensuring that [`__all__`](https://riptutorial.com/python/example/2894/the---all---special-variable) is defined in all packages. In order to see where a function is from, just type it:
 
-```python
+```
 coll_repr
 ```
 
@@ -64,13 +64,13 @@ fastcore's testing module is designed to work well with [nbdev](https://nbdev.fa
 
 Tests look like this:
 
-```python
+```
 test_eq(coll_repr(range(1000), 5), '(#1000) [0,1,2,3,4...]')
 ```
 
 That's an example from the docs for `coll_repr`. As you see, it's not showing you the output directly. Here's what that would look like:
 
-```python
+```
 coll_repr(range(1000), 5)
 ```
 
@@ -87,7 +87,7 @@ So every test shown in the docs is also showing you the behavior of the library
 
 Test functions always start with `test_`, and then follow with the operation being tested. So `test_eq` tests for equality (as you saw in the example above). This includes tests for equality of arrays and tensors, lists and generators, and many more:
 
-```python
+```
 test_eq([0,1,2,3], np.arange(4))
 ```
 
@@ -108,28 +108,28 @@ If you want to check that objects are the same type, rather than the just contai
 
 You can test with any comparison function using `test`, e.g test whether an object is less than:
 
-```python
+```
 test(2, 3, operator.lt)
 ```
 
 You can even test that exceptions are raised:
 
-```python
+```
 def divide_zero(): return 1/0
 test_fail(divide_zero)
 ```
 
 ...and test that things are printed to stdout:
 
-```python
+```
 test_stdout(lambda: print('hi'), 'hi')
 ```
 
 ### Foundations
 
 fast.ai is unusual in that we often use [mixins](https://en.wikipedia.org/wiki/Mixin) in our code. Mixins are widely used in many programming languages, such as Ruby, but not so much in Python. We use mixins to attach new behavior to existing libraries, or to allow modules to add new behavior to our own classes, such as in extension modules. One useful example of a mixin we define is `Path.ls`, which lists a directory and returns an `L` (an extended list class which we'll discuss shortly):
 
-```python
+```
 p = Path('images')
 p.ls()
 ```
@@ -143,7 +143,7 @@ p.ls()
 
 You can easily add you own mixins with the `patch` [decorator](https://realpython.com/primer-on-python-decorators/), which takes advantage of Python 3 [function annotations](https://www.python.org/dev/peps/pep-3107/#parameters) to say what class to patch:
 
-```python
+```
 @patch
 def num_items(self:Path): return len(self.ls())
 
@@ -161,7 +161,7 @@ We also use `**kwargs` frequently. In python `**kwargs` in a parameter like mean
 
 `GetAttr` solves a similar problem (and is also discussed in the article linked above): it's allows you to use Python's exceptionally useful `__getattr__` magic method, but avoids the problem that normally in Python tab-completion and docs break when using this. For instance, you can see here that Python's `dir` function, which is used to find the attributes of a python object, finds everything inside the `self.default` attribute here:
 
-```python
+```
 class Author:
     def __init__(self, name): self.name = name
 
@@ -182,7 +182,7 @@ p = ProductPage(Author("Jeremy"), 1.50, 0.50)
 
 Looking at that `ProductPage` example, it's rather verbose and duplicates a lot of attribute names, which can lead to bugs later if you change them only in one place. `fastcore` provides `store_attr` to simplify this common pattern. It also provides `basic_repr` to give simple objects a useful `repr`:
 
-```python
+```
 class ProductPage:
     def __init__(self,author,price,cost): store_attr()
     __repr__ = basic_repr('author,price,cost')
@@ -199,7 +199,7 @@ ProductPage("Jeremy", 1.50, 0.50)
 
 One of the most interesting `fastcore` functions is the `funcs_kwargs` decorator. This allows class behavior to be modified without sub-classing. This can allow folks that aren't familiar with object-oriented programming to customize your class more easily. Here's an example of a class that uses `funcs_kwargs`:
 
-```python
+```
 @funcs_kwargs
 class T:
     _methods=['some_method']
@@ -225,7 +225,7 @@ Like most languages, Python allows for very concise syntax for some very common
 
 On this basis, `fastcore` has just one type that has a single letter name:`L`. The reason for this is that it is designed to be a replacement for `list`, so we want it to be just as easy to use as `[1,2,3]`. Here's how to create that as an `L`:
 
-```python
+```
 L(1,2,3)
 ```
 
@@ -238,7 +238,7 @@ L(1,2,3)
 
 The first thing to notice is that an `L` object includes in its representation its number of elements; that's the `(#3)` in the output above. If there's more than 10 elements, it will automatically truncate the list:
 
-```python
+```
 p = L.range(20).shuffle()
 p
 ```
@@ -252,7 +252,7 @@ p
 
 `L` contains many of the same indexing ideas that NumPy's `array` does, including indexing with a list of indexes, or a boolean mask list:
 
-```python
+```
 p[2,4,6]
 ```
 
@@ -265,7 +265,7 @@ p[2,4,6]
 
 It also contains other methods used in `array`, such as `L.argwhere`:
 
-```python
+```
 p.argwhere(ge(15))
 ```
 
@@ -280,7 +280,7 @@ As you can see from this example, `fastcore` also includes a number of features
 
 There's too much functionality to show it all here, so be sure to check the docs. Many little things are added that we thought should have been in `list` in the first place, such as making this do what you'd expect (which is an error with `list`, but works fine with `L`):
 
-```python
+```
 1 + L(2,3,4)
 ```
 
@@ -295,7 +295,7 @@ There's too much functionality to show it all here, so be sure to check the docs
 
 Most Python programmers use object oriented methods and inheritance to allow different objects to behave in different ways even when called with the same method name. Some languages use a very different approach, such as Julia, which uses [multiple dispatch generic functions](https://docs.julialang.org/en/v1/manual/methods/). Python provides [single dispatch generic functions](https://www.python.org/dev/peps/pep-0443/) as part of the standard library. `fastcore` provides multiple dispatch, with the `typedispatch` decorator (which is actually an instance of `DispatchReg`):
 
-```python
+```
 @typedispatch
 def _f(x:numbers.Integral, y): return x+1
 @typedispatch
@@ -324,7 +324,7 @@ This approach to dispatch is particularly useful for adding implementations of f
 
 `Transform` looks for three special methods, <code>encodes</code>, <code>decodes</code>, and <code>setups</code>, which provide the implementation for [`__call__`](https://www.python-course.eu/python3_magic_methods.php), `decode`, and `setup` respectively. For instance:
 
-```python
+```
 class A(Transform):
     def encodes(self, x): return x+1
 
@@ -340,7 +340,7 @@ A()(1)
 
 For simple transforms like this, you can also use `Transform` as a decorator:
 
-```python
+```
 @Transform
 def f(x): return x+1
 
@@ -356,7 +356,7 @@ f(1)
 
 Transforms can be composed into a `Pipeline`:
 
-```python
+```
 @Transform
 def g(x): return x/2
 

fastcore/foundation.py

@@ -241,33 +241,24 @@ def save_config_file(file, d, **kwargs):
 def read_config_file(file, **kwargs):
     config = ConfigParser(**kwargs)
     config.read(file)
-    return config
-
-# Cell
-def _add_new_defaults(cfg, file, **kwargs):
-    for k,v in kwargs.items():
-        if cfg.get(k, None) is None:
-            cfg[k] = v
-            save_config_file(file, cfg)
+    return config['DEFAULT']
 
 # Cell
 @lru_cache(maxsize=None)
 class Config:
-    "Reading and writing `settings.ini`"
-    def __init__(self, cfg_name='settings.ini'):
-        cfg_path = Path.cwd()
-        while cfg_path != cfg_path.parent and not (cfg_path/cfg_name).exists(): cfg_path = cfg_path.parent
+    "Reading and writing `ConfigParser` ini files"
+    def __init__(self, cfg_path, cfg_name):
+        cfg_path = Path(cfg_path).expanduser().absolute()
         self.config_path,self.config_file = cfg_path,cfg_path/cfg_name
         assert self.config_file.exists(), f"Could not find {cfg_name}"
-        self.d = read_config_file(self.config_file)['DEFAULT']
-        _add_new_defaults(self.d, self.config_file,
-                         host="github", doc_host="https://%(user)s.github.io", doc_baseurl="/%(lib_name)s/")
+        self.d = read_config_file(self.config_file)
 
     def __setitem__(self,k,v): self.d[k] = str(v)
     def __contains__(self,k):  return k in self.d
     def save(self):            save_config_file(self.config_file,self.d)
     def __getattr__(self,k):   return stop(AttributeError(k)) if k=='d' or k not in self.d else self.get(k)
     def get(self,k,default=None): return self.d.get(k, default)
+
     def path(self,k,default=None):
         v = self.get(k, default)
         return v if v is None else self.config_path/v

nbs/02_foundation.ipynb

@@ -792,7 +792,7 @@
     {
      "data": {
       "text/plain": [
-       "['j', 5, 10]"
+       "[7, 0, 'j']"
       ]
      },
      "execution_count": null,
@@ -1847,7 +1847,7 @@
     "def read_config_file(file, **kwargs):\n",
     "    config = ConfigParser(**kwargs)\n",
     "    config.read(file)\n",
-    "    return config"
+    "    return config['DEFAULT']"
    ]
   },
   {
@@ -1868,21 +1868,7 @@
     "    save_config_file('tmp.ini', _d)\n",
     "    res = read_config_file('tmp.ini')\n",
     "finally: os.unlink('tmp.ini')\n",
-    "test_eq(res['DEFAULT'], _d)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#export\n",
-    "def _add_new_defaults(cfg, file, **kwargs):\n",
-    "    for k,v in kwargs.items():\n",
-    "        if cfg.get(k, None) is None:\n",
-    "            cfg[k] = v\n",
-    "            save_config_file(file, cfg)"
+    "test_eq(res, _d)"
    ]
   },
   {
@@ -1894,21 +1880,19 @@
     "#export\n",
     "@lru_cache(maxsize=None)\n",
     "class Config:\n",
-    "    \"Reading and writing `settings.ini`\"\n",
-    "    def __init__(self, cfg_name='settings.ini'):\n",
-    "        cfg_path = Path.cwd()\n",
-    "        while cfg_path != cfg_path.parent and not (cfg_path/cfg_name).exists(): cfg_path = cfg_path.parent\n",
+    "    \"Reading and writing `ConfigParser` ini files\"\n",
+    "    def __init__(self, cfg_path, cfg_name):\n",
+    "        cfg_path = Path(cfg_path).expanduser().absolute()\n",
     "        self.config_path,self.config_file = cfg_path,cfg_path/cfg_name\n",
     "        assert self.config_file.exists(), f\"Could not find {cfg_name}\"\n",
-    "        self.d = read_config_file(self.config_file)['DEFAULT']\n",
-    "        _add_new_defaults(self.d, self.config_file,\n",
-    "                         host=\"github\", doc_host=\"https://%(user)s.github.io\", doc_baseurl=\"/%(lib_name)s/\")\n",
+    "        self.d = read_config_file(self.config_file)\n",
     "\n",
     "    def __setitem__(self,k,v): self.d[k] = str(v)\n",
     "    def __contains__(self,k):  return k in self.d\n",
     "    def save(self):            save_config_file(self.config_file,self.d)\n",
     "    def __getattr__(self,k):   return stop(AttributeError(k)) if k=='d' or k not in self.d else self.get(k)\n",
     "    def get(self,k,default=None): return self.d.get(k, default)\n",
+    "\n",
     "    def path(self,k,default=None):\n",
     "        v = self.get(k, default)\n",
     "        return v if v is None else self.config_path/v"
@@ -1918,7 +1902,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "`Config` searches parent directories for a config file, and provides direct access to the 'DEFAULT' section. Keys ending in `_path` are converted to paths in the config file's directory."
+    "`Config` and provides direct access to the 'DEFAULT' section of a `ConfigParser` ini file."
    ]
   },
   {
@@ -1929,13 +1913,12 @@
    "source": [
     "try:\n",
     "    save_config_file('../tmp.ini', _d)\n",
-    "    cfg = Config('tmp.ini')\n",
+    "    cfg = Config('..', 'tmp.ini')\n",
     "finally: os.unlink('../tmp.ini')\n",
     "\n",
     "test_eq(cfg.user,'fastai')\n",
-    "test_eq(cfg.doc_baseurl,'/fastcore/')\n",
     "test_eq(cfg.get('some_path'), 'test')\n",
-    "test_eq(cfg.path('some_path'), Path('../test').resolve())\n",
+    "test_eq(cfg.path('some_path'), Path('../test').absolute())\n",
     "test_eq(cfg.get('foo','bar'),'bar')"
    ]
   },
@@ -1965,7 +1948,8 @@
       "Converted 05_transform.ipynb.\n",
       "Converted 07_meta.ipynb.\n",
       "Converted 08_script.ipynb.\n",
-      "Converted index.ipynb.\n"
+      "Converted index.ipynb.\n",
+      "Converted parallel_win.ipynb.\n"
      ]
     }
    ],