:py:mod:`webapp.pgconfig`
=========================

.. py:module:: webapp.pgconfig

.. autoapi-nested-parse::

   Parses PostgreSQL config data from pickled files



Module Contents
---------------


Functions
~~~~~~~~~

.. autoapisummary::

   webapp.pgconfig.check_redirect
   webapp.pgconfig.config_changes
   webapp.pgconfig.squash_columns
   webapp.pgconfig.load_config_data
   webapp.pgconfig.is_NaN
   webapp.pgconfig.classify_changes
   webapp.pgconfig.calculate_change_display
   webapp.pgconfig.config_changes_html
   webapp.pgconfig.config_changes_stats
   webapp.pgconfig._df_to_html
   webapp.pgconfig.get_all_postgres_parameters
   webapp.pgconfig.get_pg_param_over_versions
   webapp.pgconfig.history_df_to_html



Attributes
~~~~~~~~~~

.. autoapisummary::

   webapp.pgconfig.LOGGER
   webapp.pgconfig.VERSIONS
   webapp.pgconfig.VERSION_REDIRECTS
   webapp.pgconfig.NEW_STRING
   webapp.pgconfig.REMOVED_STRING


.. py:data:: LOGGER

   

.. py:data:: VERSIONS
   :value: ['10', '11', '12', '13', '14', '15', '16']

   Versions with data included. Add new versions to this list.
   When including pre-production versions include a non-production designation,
   e.g. 16beta1

   :type: list

.. py:data:: VERSION_REDIRECTS

   List of dictionaries. Dict keys are 'version' and 'redirect'.

   :type: list

.. py:data:: NEW_STRING
   :value: 'Configuration parameter added'

   

.. py:data:: REMOVED_STRING
   :value: 'Configuration parameter removed'

   

.. py:function:: check_redirect(version)

   Checks version for defined redirects.

   e.g. 12beta4 redirects to 12 once the production-ready version
   is released.

   :param version: Version to check for redirects for.
   :type version: str

   :returns: **version** -- Redirected if necessary, original version if not.
   :rtype: str


.. py:function:: config_changes(vers1: int, vers2: int) -> pandas.DataFrame

   Find changes between `vers1` and `vers2`.

   :param vers1: Version number, e.g. 11 or 16
   :type vers1: int
   :param vers2: Version number, e.g. 11 or 16
   :type vers2: int

   :returns: **changed**
   :rtype: pd.DataFrame


.. py:function:: squash_columns(data: pandas.DataFrame, original_columns: list, new_column: str)

   Coalesces the values from DataFrame columns in `original_columns` list
   into the `new_column` name.  Drops `original_columns`, so can reuse one of
   the column names if desired. e.g `short_desc` and `short_desc2` combined
   into the `short_desc` column.

   Note: This is useful for added and removed items, NOT changed items.

   :param data:
   :type data: pd.DataFrame
   :param original_columns:
   :type original_columns: list
   :param new_column:
   :type new_column: str

   :returns: **data_new**
   :rtype: pd.DataFrame


.. py:function:: load_config_data(pg_version: int) -> pandas.DataFrame

   Loads the pickled config data for `pg_version` into DataFrame with the
   config name as the index.

   Returns empty DataFrame on file read error.

   :param pg_version:
   :type pg_version: int

   :returns: **df**
   :rtype: pd.DataFrame


.. py:function:: is_NaN(input: str) -> bool

   Checks string values for NaN, aka it isn't equal to itself.

   :param input:
   :type input: str

   :returns: **is_nan**
   :rtype: bool


.. py:function:: classify_changes(row: pandas.Series) -> str

   Used by dataFrame.apply on the combined DataFrame to check version1 and
   version2 values, types, etc. for differences.

   :param row: Row from combined DataFrame to check details.
   :type row: pd.Series

   :returns: **changes** -- Changes are built as a list internally and returned as a string
             with a comma separated list of changes.
   :rtype: str


.. py:function:: calculate_change_display(row: pandas.Series) -> str

   Used by dataFrame.apply on the combined DataFrame to create the columns
   to display for changes.

   :param row: Row from combined DataFrame to check details.
   :type row: pd.Series

   :returns: **changes** -- Changes are built as a list internally and returned as a string
             with a comma separated list of changes.
   :rtype: str


.. py:function:: config_changes_html(changes: pandas.DataFrame) -> dict

   Splits `changes` data into new, removed, and changed.

   :param changes:
   :type changes: pd.DataFrame

   :returns: **changes_html** --

             Dictionary with keys:
                 * new
                 * removed
                 * changed

             Each item holds the string HTML for the table of the data from input
             DataFrame
   :rtype: dict


.. py:function:: config_changes_stats(changes: dict) -> dict

   Provides counts of changes by type (new, removed, updated) to display.

   :param changes:
   :type changes: dict

   :returns: **stats**
   :rtype: dict


.. py:function:: _df_to_html(df)

   Converts DataFrame to HTML table with classes for formatting.

   :param df:
   :type df: pandas.DataFrame

   :returns: HTML table for display.
   :rtype: str


.. py:function:: get_all_postgres_parameters() -> set

   Returns sorted set of Postgres parameters from all versions.

   :returns: **all_parameters**
   :rtype: set


.. py:function:: get_pg_param_over_versions(pg_param: str) -> dict

   Return details about pg_param over Postgres major versions.

   :param pg_param: Name of the Postgres parameter
   :type pg_param: str

   :returns: **param_details**
   :rtype: dict


.. py:function:: history_df_to_html(history: dict, pg_param: str) -> str

   Converts a dictionary of details across versions to HTML for display on
   frontend.

   :param history:
   :type history: dict
   :param pg_param:
   :type pg_param: str

   :returns: **history_html**
   :rtype: str