2.3.0 - New collections module + refactoring

**Minor updates**

 - `docs/source/conf.py` now sets `PYTHON_PATH` which helps reduce issues with Sphinx
   finding the privex package folder

 - Fleshed out `docs/source/examples.rst` with `DictObject` and `dictable_namedtuple` examples.

 - Added documentation for `privex.helpers.collections` and `tests.test_tuple`

 - Added `Pipfile` and `Pipfile.lock` for use with `pipenv` during development

**Major changes**

 - Created module `privex.helpers.collections`

   - `DictObject` - A `dict` sub-class which allows keys to be read/written via
     attributes (`x.something`) as well as standard item/key notation (`x['something']`)

   - `MockDictObj` - Same as `DictObject`, but masquerades as the builtin `dict`, potentially
     allowing it to be used with certain code that expects the builtin dict type

   - `is_namedtuple` - Boolean function which returns `True` if all passed objects are named tuples

   - `dictable_namedtuple` - A sub-class of the native `collections.namedtuple`, which adds additional functionality
     such as dict-like key/item access to fields, ability to cast directly to a dict, and ability to add new fields
     dynamically to an existing instance.

   - `convert_dictable_namedtuple` - Converts a `namedtuple` type class instance into a `dictable_namedtuple` instance

   - `subclass_dictable_namedtuple` - Converts a `namedtuple` type/class into a `dictable_namedtuple` type/class

 - Created unit tests for `is_namedtuple` and `dictable_namedtuple` in `tests/test_tuple.py`

**BREAKING CHANGES**

 - `Mocker` has been moved from `privex.helpers.common` into `privex.helpers.collections`.
   Code which imports via `from privex.helpers.common import Mocker` will no longer work.
   Code which imports `Mocker` from the shared `privex.helpers` module (i.e. `from privex.helpers import Mocker`)
   should be unaffected.

 - `Dictable` has been moved from `privex.helpers.common` into `privex.helpers.collections`.
   Code which imports via `from privex.helpers.common import Dictable` will no longer work.
   Code which imports `Dictable` from the shared `privex.helpers` module (i.e. `from privex.helpers import Dictable`)
   should be unaffected.

Author: Someguy123

Pipfile

@@ -0,0 +1,31 @@
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[dev-packages]
+pytest = "*"
+pytest-cov = "*"
+coverage = "*"
+codecov = "*"
+twine = "*"
+semver = "*"
+Sphinx = ">=2.1.2"
+sphinx-autobuild = ">=0.7.1"
+restructuredtext-lint = ">=1.3.0"
+sphinx-rtd-theme = ">=0.4.3"
+docutils = ">=0.14"
+wheel = "*"
+setuptools = "*"
+
+[packages]
+privex-loghelper = "*"
+redis = ">=3.3"
+cryptography = ">=2.8"
+dnspython = ">=1.16"
+Django = "*"
+MarkupSafe = ">=1.1.1"
+wheel = "*"
+
+[requires]
+python_version = "3.8"

Pipfile.lock

@@ -24,6 +24,12 @@
 BASE_DIR = dirname(dirname(dirname(abspath(__file__))))
 
 sys.path.insert(0, BASE_DIR)
+PY_PATH = os.getenv('PYTHON_PATH', '')
+
+if PY_PATH != '':
+    PY_PATH = ':' + PY_PATH
+
+os.environ['PYTHON_PATH'] = BASE_DIR + PY_PATH
 
 # -- Project information -----------------------------------------------------
 

docs/source/conf.py

@@ -99,3 +99,133 @@ easily converted into a dictionary using ``dict()``.
     env_keyval('NOEXIST', {})
     # returns: {}
 
+
+Improved collections, including dict's and namedtuple's
+=======================================================
+
+In our :py:mod:`privex.helpers.collections` module (plus maybe a few things in :py:mod:`privex.helpers.common`),
+we have various functions and classes designed to make working with Python's storage types more painless, while
+trying to keep compatibility with code that expects the native types.
+
+
+Dictionaries with dot notation attribute read/write
+---------------------------------------------------
+
+Dictionaries (``dict``) are powerful, and easy to deal with. But why can't you read or write dictionary items with 
+attribute dot notation!?
+
+This is where :class:`.DictObject` comes in to save the day. It's a child class of python's native :class:`dict` type, which
+means it's still compatible with functions/methods such as :func:`json.dumps`, and in most cases will be plug-n-play with
+existing dict-using code.
+
+**Basic usage**
+
+.. code-block:: python
+
+    from privex.helpers import DictObject
+
+    x = dict(hello='world', lorem='ipsum')
+    x['hello']  # This works with a normal dict
+    x.hello     # But this raises: AttributeError: 'dict' object has no attribute 'hello'
+
+    # We can cast the dict 'x' into a DictObject
+    y = DictObject(x)
+    y['hello']         # Returns: 'world'
+    y.hello            # Returns: 'world'
+
+    # Not only can you access dict keys via attributes, you can also set keys via attributes
+    y.example = 'testing'
+    y                  # We can see below that setting 'example' worked as expected.
+    # Output: {'hello': 'world', 'lorem': 'ipsum', 'example': 'testing'}
+
+
+**Type checking / Equality comparison**
+
+As :class:`.DictObject` is a subclass of :class:`dict`, you can use :func:`isinstance` to check against :class:`dict` 
+(e.g.  ``isinstance(DictObject(), dict)``) and it should return True.
+
+You can also compare dictionary equality between a :class:`.DictObject` and a :class:`dict` using ``==`` as normal.
+
+.. code-block:: python
+
+    y = DictObject(hello='world')
+
+    isinstance(y, dict)   # You should always use isinstance instead of `type(x) == dict`
+    # Returns: True
+
+    # You can also use typing.Dict with isinstance when checking a DictObject
+    from typing import Dict
+    isinstance(y, Dict)   # Returns: True
+
+    # You can compare equality between a DictObject and a dict with no problems
+    DictObject(hello='world') == dict(hello='world')
+    # Returns: True
+    DictObject(hello='world') == dict(hello='example')
+    # Returns: False
+
+**Type Masquerading**
+
+Also included is the class :class:`.MockDictObj`, which is a subclass of :class:`.DictObject` with it's name, qualified name,
+and module adjusted so that it appears to be the builtin :class:`dict` type.
+
+This may help in some cases, but sadly can't fool a ``type(x) == dict`` check.
+
+.. code-block:: python
+
+    from privex.helpers import MockDictObj
+    z = MockDictObj(y)
+    type(z)                  # Returns: <class 'dict'>
+    z.__class__.__module__   # Returns: 'builtins'
+
+
+
+Named Tuple's (namedtuple) with dict-like key access, dict casting, and writable fields
+---------------------------------------------------------------------------------------
+
+A somewhat simpler version of :class:`dict`'s are :func:`collections.namedtuple`'s
+
+Unfortunately they have a few quirks that can make them annoying to deal with.
+
+.. code-block:: python
+
+    Person = namedtuple('Person', 'first_name last_name')  # This is an existing namedtuple "type" or "class"
+    john = Person('John', 'Doe')  # This is an existing namedtuple instance
+    john.first_name               # This works on a standard namedtuple. Returns: John
+    john[1]                       # This works on a standard namedtuple. Returns: Doe
+    john['first_name']            # However, this would throw a TypeError.
+    dict(john)                    # This would throw a ValueError.
+    john.address = '123 Fake St'  # This raises an AttributeError.
+
+Thus, we created :func:`.dictable_namedtuple` (and more), which creates namedtuples with additional functionality,
+including item/key access of fields, easy casting into dictionaries, and ability to add new fields.
+
+.. code-block:: python
+
+    from privex.helpers import dictable_namedtuple
+    Person = dictable_namedtuple('Person', 'first_name last_name')
+    john = Person('John', 'Doe')
+    dave = Person(first_name='Dave', last_name='Smith')
+    print(dave['first_name'])       # Prints:  Dave
+    print(dave.first_name)          # Prints:  Dave
+    print(john[1])                  # Prints:  Doe
+    print(dict(john))               # Prints:  {'first_name': 'John', 'last_name': 'Doe'}
+    john.address = '123 Fake St'    # Unlike normal namedtuple, we can add new fields
+    print(john)                     # Prints: Person(first_name='John', last_name='Doe', address='123 Fake St')
+
+
+You can use :func:`.convert_dictable_namedtuple` to convert existing ``namedtuple`` instancess
+into ``dictable_namedtuple`` instances:
+
+.. code-block:: python
+
+    Person = namedtuple('Person', 'first_name last_name')  # This is an existing namedtuple "type" or "class"
+    john = Person('John', 'Doe')  # This is an existing namedtuple instance
+
+    d_john = convert_dictable_namedtuple(john)
+    d_john.first_name               # Returns: John
+    d_john[1]                       # Returns: Doe
+    d_john['first_name']            # Returns: 'John'
+    dict(d_john)                    # Returns: {'first_name': 'John', 'last_name': 'Doe'}
+
+For more information, check out the module docs at :mod:`privex.helpers.collections`
+

docs/source/examples.rst

@@ -0,0 +1,6 @@
+from\_dict
+==========
+
+.. currentmodule:: privex.helpers.collections
+
+.. automethod:: Dictable.from_dict

docs/source/helpers/collections/dictable/privex.helpers.collections.Dictable.from_dict.rst

@@ -1,6 +1,6 @@
 \_\_init\_\_
 ============
 
-.. currentmodule:: privex.helpers.common
+.. currentmodule:: privex.helpers.collections
 
 .. automethod:: Mocker.__init__

…rivex.helpers.common.Mocker.__init__.rst ….helpers.collections.Mocker.__init__.rstdocs/source/helpers/common/mocker/privex.helpers.common.Mocker.__init__.rst renamed to docs/source/helpers/collections/mocker/privex.helpers.collections.Mocker.__init__.rst docs/source/helpers/common/mocker/privex.helpers.common.Mocker.__init__.rst renamed to docs/source/helpers/collections/mocker/privex.helpers.collections.Mocker.__init__.rst

@@ -1,6 +1,6 @@
 add\_mock\_module
 =================
 
-.. currentmodule:: privex.helpers.common
+.. currentmodule:: privex.helpers.collections
 
 .. automethod:: Mocker.add_mock_module

…elpers.common.Mocker.add_mock_module.rst …s.collections.Mocker.add_mock_module.rstdocs/source/helpers/common/mocker/privex.helpers.common.Mocker.add_mock_module.rst renamed to docs/source/helpers/collections/mocker/privex.helpers.collections.Mocker.add_mock_module.rst docs/source/helpers/common/mocker/privex.helpers.common.Mocker.add_mock_module.rst renamed to docs/source/helpers/collections/mocker/privex.helpers.collections.Mocker.add_mock_module.rst

@@ -1,6 +1,6 @@
 make\_mock\_class
 =================
 
-.. currentmodule:: privex.helpers.common
+.. currentmodule:: privex.helpers.collections
 
 .. automethod:: Mocker.make_mock_class

…elpers.common.Mocker.make_mock_class.rst …s.collections.Mocker.make_mock_class.rstdocs/source/helpers/common/mocker/privex.helpers.common.Mocker.make_mock_class.rst renamed to docs/source/helpers/collections/mocker/privex.helpers.collections.Mocker.make_mock_class.rst docs/source/helpers/common/mocker/privex.helpers.common.Mocker.make_mock_class.rst renamed to docs/source/helpers/collections/mocker/privex.helpers.collections.Mocker.make_mock_class.rst

@@ -0,0 +1,25 @@
+DictObject
+==========
+
+.. currentmodule:: privex.helpers.collections
+
+.. autoclass:: DictObject
+
+
+   .. automethod:: __init__
+      :noindex:
+
+
+Methods
+^^^^^^^
+
+.. rubric:: Methods
+
+.. autosummary::
+   :toctree: dictobject
+
+
+
+
+
+

docs/source/helpers/collections/privex.helpers.collections.DictObject.rst

@@ -0,0 +1,26 @@
+Dictable
+========
+
+.. currentmodule:: privex.helpers.collections
+
+.. autoclass:: Dictable
+
+
+   .. automethod:: __init__
+      :noindex:
+
+
+Methods
+^^^^^^^
+
+.. rubric:: Methods
+
+.. autosummary::
+   :toctree: dictable
+
+    ~Dictable.from_dict
+
+
+
+
+