pseudopeople 0.1.0__py3-none-any.whl

pseudopeople/__about__.py

@@ -0,0 +1,22 @@
+__all__ = [
+    "__title__",
+    "__summary__",
+    "__uri__",
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    "__copyright__",
+]
+
+__title__ = "pseudopeople"
+__summary__ = "pseudopeople is package which adds noise to simulated census-scale data using standard scientific Python tools."
+__uri__ = "https://github.com/ihmeuw/pseudopeople"
+
+__version__ = "0.1.0"
+
+__author__ = "The pseudopeople developers"
+__email__ = "vivarium.dev@gmail.com"
+
+__license__ = "BSD-3-Clause"
+__copyright__ = f"Copyright 2023 {__author__}"

pseudopeople/__init__.py

@@ -0,0 +1,11 @@
+from pseudopeople.__about__ import (
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __summary__,
+    __title__,
+    __uri__,
+    __version__,
+)
+from pseudopeople.interface import generate_decennial_census

pseudopeople/default_configuration.yaml

@@ -0,0 +1,54 @@
+# Default noising configuration
+# structure follows:
+#   Row noise: `form.noise_type`
+#   Column-wise parameters: `form.column.noise_type.noise_parameter`
+
+decennial_census:
+    omission: 0.0145
+    duplication: 0.05
+    first_name:
+        missing_data:
+            row_noise_level: 0.01
+    middle_initial:
+        missing_data:
+            row_noise_level: 0.01
+    last_name:
+        missing_data:
+            row_noise_level: 0.01
+    age:
+        missing_data:
+            row_noise_level: 0.01
+    date_of_birth:
+        missing_data:
+            row_noise_level: 0.01
+    street_number:
+        missing_data:
+            row_noise_level: 0.01
+    street_name:
+        missing_data:
+            row_noise_level: 0.01
+    unit_number:
+        missing_data:
+            row_noise_level: 0.01
+    city:
+        missing_data:
+            row_noise_level: 0.01
+    state:
+        missing_data:
+            row_noise_level: 0.01
+    zipcode:
+        missing_data:
+            row_noise_level: 0.01
+    relation_to_household_head:
+        missing_data:
+            row_noise_level: 0.01
+    sex:
+        missing_data:
+            row_noise_level: 0.01
+    race_ethnicity:
+        missing_data:
+            row_noise_level: 0.01
+    housing_type:
+        missing_data:
+            row_noise_level: 0.01
+

pseudopeople/entities.py

@@ -0,0 +1,97 @@
+from enum import Enum
+from typing import NamedTuple
+
+from pseudopeople import noise_functions
+from pseudopeople.entity_types import ColumnNoiseType, RowNoiseType
+
+
+# todo: is "form" the right word? Ask RT
+class Form(Enum):
+    CENSUS = "decennial_census"
+    ACS = "american_communities_survey"
+    CPS = "current_population_survey"
+    WIC = "women_infants_and_children"
+    SSA = "social_security"
+    TAX_W2_1099 = "taxes_w2_and_1099"
+    TAX_1040 = "taxes_1040"
+
+
+class __Columns(NamedTuple):
+    FIRST_NAME: str = "first_name"
+    MIDDLE_INITIAL: str = "middle_initial"
+    LAST_NAME: str = "last_name"
+    STREET_NAME: str = "street_name"
+    ZIP_CODE: str = "zipcode"
+    CITY: str = "city"
+    AGE: str = "age"
+    # todo finish filling in columns
+
+
+COLUMNS = __Columns()
+
+
+class __NoiseTypes(NamedTuple):
+    """Container for all noise types in the order in which they should be applied:
+    omissions, duplications, missing data, incorrect selection, copy from w/in
+    household, month and day swaps, zip code miswriting, age miswriting,
+    numeric miswriting, nicknames, fake names, phonetic, OCR, typographic"
+    """
+
+    # todo finish filling in noise types in the correct order per the docs
+    OMISSION: RowNoiseType = RowNoiseType("omission", noise_functions.omit_rows)
+    DUPLICATION: RowNoiseType = RowNoiseType("duplication", noise_functions.duplicate_rows)
+    MISSING_DATA: ColumnNoiseType = ColumnNoiseType(
+        "missing_data",
+        noise_functions.generate_missing_data,
+    )
+    INCORRECT_SELECTION: ColumnNoiseType = ColumnNoiseType(
+        "incorrect_selection", noise_functions.generate_incorrect_selections
+    )
+    COPY_FROM_WITHIN_HOUSEHOLD: ColumnNoiseType = ColumnNoiseType(
+        "copy_from_within_household", noise_functions.generate_within_household_copies
+    )
+    MONTH_DAY_SWAP: ColumnNoiseType = ColumnNoiseType(
+        "month_day_swap", noise_functions.swap_months_and_days
+    )
+    ZIP_CODE_MISWRITING: ColumnNoiseType = ColumnNoiseType(
+        "zipcode_miswriting", noise_functions.miswrite_zip_codes
+    )
+    AGE_MISWRITING: ColumnNoiseType = ColumnNoiseType(
+        "age_miswriting", noise_functions.miswrite_ages
+    )
+    NUMERIC_MISWRITING: ColumnNoiseType = ColumnNoiseType(
+        "numeric_miswriting", noise_functions.miswrite_numerics
+    )
+    NICKNAME: ColumnNoiseType = ColumnNoiseType(
+        "nickname", noise_functions.generate_nicknames
+    )
+    FAKE_NAME: ColumnNoiseType = ColumnNoiseType(
+        "fake_names", noise_functions.generate_fake_names
+    )
+    PHONETIC: ColumnNoiseType = ColumnNoiseType(
+        "phonetic", noise_functions.generate_phonetic_errors
+    )
+    OCR: ColumnNoiseType = ColumnNoiseType(
+        # todo: implement the noise fn
+        "ocr",
+        noise_functions.generate_ocr_errors,
+    )
+    TYPOGRAPHIC: ColumnNoiseType = ColumnNoiseType(
+        "typographic",
+        noise_functions.generate_typographical_errors,
+    )
+
+
+NOISE_TYPES = __NoiseTypes()
+
+
+class NoiseParameter(Enum):
+    """
+    Enum containing all additional parameters used to specify column noise.
+    """
+
+    ROW_NOISE_LEVEL = "row_noise_level"
+    TOKEN_NOISE_LEVEL = "token_noise_level"
+    TYPOGRAPHIC_NOISE = "typographic_noise"
+    AGE_MISWRITING = "age_miswriting"
+    ZIPCODE_MISWRITING = "zipcode_miswriting"

pseudopeople/entity_types.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+from typing import Any, Callable
+
+import pandas as pd
+from vivarium import ConfigTree
+from vivarium.framework.randomness import RandomnessStream
+
+
+@dataclass
+class RowNoiseType:
+    """
+    Defines a type of noise that can be applied to a row.
+
+    The name is the name of the particular noise function (e.g. "omission" or
+    "duplication").
+
+    The noise function takes as input a DataFrame, the configuration value
+    for this RowNoise operation, and a RandomnessStream for controlling
+    randomness. It applies the noising operation to the entire DataFrame and
+    returns the modified DataFrame.
+    """
+
+    name: str
+    noise_function: Callable[[pd.DataFrame, float, RandomnessStream, str], pd.DataFrame]
+
+    def __call__(
+        self,
+        form_data: pd.DataFrame,
+        configuration: float,
+        randomness_stream: RandomnessStream,
+    ) -> pd.DataFrame:
+        return self.noise_function(form_data, configuration, randomness_stream)
+
+
+@dataclass
+class ColumnNoiseType:
+    """
+    Defines a type of noise that can be applied to a column.
+
+    The name is the name of the particular noise function (e.g. "nickname" or
+    "phonetic").
+
+    The noise function takes as input a Series, the ConfigTree object for this
+    ColumnNoise operation, a RandomnessStream for controlling randomness, and
+    an additional key for the RandomnessStream. It applies the noising operation
+    to the Series and returns the modified Series.
+    """
+
+    name: str
+    noise_function: Callable[[pd.Series, ConfigTree, RandomnessStream, Any], pd.Series]
+
+    def __call__(
+        self,
+        column: pd.Series,
+        configuration: ConfigTree,
+        randomness_stream: RandomnessStream,
+        additional_key: Any,
+    ) -> pd.Series:
+        return self.noise_function(column, configuration, randomness_stream, additional_key)

pseudopeople/interface.py

@@ -0,0 +1,43 @@
+import sys
+from pathlib import Path
+from typing import Union
+
+import pandas as pd
+
+from pseudopeople.entities import Form
+from pseudopeople.noise import noise_form
+from pseudopeople.utilities import get_configuration
+
+
+# TODO: add year as parameter to select the year of the decennial census to generate (MIC-3909)
+# TODO: add default path: have the package install the small data in a known location and then
+#  to make this parameter optional, with the default being the location of the small data that
+#  is installed with the package (MIC-3884)
+def generate_decennial_census(
+    path: Union[Path, str], seed: int = 0, configuration: Union[Path, str] = None
+):
+    """
+    Generates a noised decennial census data from un-noised data.
+
+    :param path: A path to the un-noised source census data
+    :param seed: An integer seed for randomness
+    :param configuration: (optional) A path to a configuration YAML file to modify default values
+    :return: A pd.DataFrame of noised census data
+    """
+    configuration_tree = get_configuration(configuration)
+    data = pd.read_csv(path)
+    return noise_form(Form.CENSUS, data, configuration_tree, seed)
+
+
+# Manual testing helper
+if __name__ == "__main__":
+    args = sys.argv[1:]
+    if len(args) == 1:
+        my_path = Path(args[0])
+        src = pd.read_csv(my_path)
+        out = generate_decennial_census(my_path)
+        diff = src[
+            ~src.astype(str).apply(tuple, 1).isin(out.astype(str).apply(tuple, 1))
+        ]  # get all changed rows
+        print(out.head())
+        print(diff)

pseudopeople/noise.py

@@ -0,0 +1,74 @@
+"""
+================
+   Noise Form
+================
+
+A function that will noise data based on a user's configuration.
+
+This function is the core of Pseudopeople, which takes in a pd.DataFrame, or form
+data and will add noise to both rows and columns based on the configured values
+provided by the user.  First, the Form will be noised for missing data and have
+rows in each columns changed to null values.  Then, the form data will be noised
+by column and row for each type of additional noise type.
+"""
+import pandas as pd
+from vivarium import ConfigTree
+
+from pseudopeople.entities import NOISE_TYPES, Form
+from pseudopeople.entity_types import ColumnNoiseType, RowNoiseType
+from pseudopeople.utilities import get_randomness_stream
+
+
+def noise_form(
+    form: Form,
+    form_data: pd.DataFrame,
+    configuration: ConfigTree,
+    seed: int,
+) -> pd.DataFrame:
+    """
+    Adds noise to the input form data. Noise functions are executed in the order
+    defined by :py:const: `.NOISE_TYPES`. Row noise functions are applied to the
+    whole DataFrame. Column noise functions will be applied to each column that
+    is pertinent to it.
+
+    Noise levels are determined by the noise_config.
+    :param form:
+        Form needing to be noised
+    :param form_data:
+        Clean data input which needs to be noised.
+    :param configuration:
+        Object to configure noise levels
+    :param seed:
+        Seed for controlling randomness
+    :return:
+        Noised form data
+    """
+    randomness = get_randomness_stream(form, seed)
+
+    noise_configuration = configuration[form.value]
+    for noise_type in NOISE_TYPES:
+        if isinstance(noise_type, RowNoiseType):
+            # Apply row noise
+            form_data = noise_type(form_data, noise_configuration, randomness)
+
+        elif isinstance(noise_type, ColumnNoiseType):
+            columns_to_noise = [
+                col
+                for col in noise_configuration
+                if col in form_data.columns and noise_type.name in noise_configuration[col]
+            ]
+            # Apply column noise to each column as appropriate
+            for column in columns_to_noise:
+                form_data[column] = noise_type(
+                    form_data[column],
+                    noise_configuration[column][noise_type.name],
+                    randomness,
+                    column,
+                )
+        else:
+            raise TypeError(
+                f"Invalid noise type. Allowed types are {RowNoiseType} and "
+                f"{ColumnNoiseType}. Provided {type(noise_type)}."
+            )
+
+    return form_data

pseudopeople/noise_functions.py

@@ -0,0 +1,268 @@
+from typing import Any
+
+import pandas as pd
+from vivarium import ConfigTree
+from vivarium.framework.randomness import RandomnessStream
+
+
+def omit_rows(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :return:
+    """
+    # todo actually omit rows
+    return form_data
+
+
+def duplicate_rows(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def generate_incorrect_selections(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def generate_within_household_copies(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def swap_months_and_days(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def miswrite_zip_codes(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def miswrite_ages(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def miswrite_numerics(
+    form_data: pd.DataFrame,
+    configuration: float,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.DataFrame:
+    """
+
+    :param form_data:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually duplicate rows
+    return form_data
+
+
+def generate_nicknames(
+    column: pd.Series,
+    configuration: ConfigTree,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.Series:
+    """
+
+    :param column:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually generate nicknames
+    return column
+
+
+def generate_fake_names(
+    column: pd.Series,
+    configuration: ConfigTree,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.Series:
+    """
+
+    :param column:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually generate fake names
+    return column
+
+
+def generate_phonetic_errors(
+    column: pd.Series,
+    configuration: ConfigTree,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.Series:
+    """
+
+    :param column:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually generate fake names
+    return column
+
+
+def generate_missing_data(
+    column: pd.Series,
+    configuration: ConfigTree,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.Series:
+    """
+    Function that takes a column and blanks out a configurable portion of its data to be missing.
+
+    :param column:  pd.Series of data
+    :param configuration: ConfigTree with rate at which to blank the data in column.
+    :param randomness_stream:  RandomnessStream to utilize Vivarium CRN.
+    :param additional_key: Key for RandomnessStream
+    :returns: pd.Series of column with configured amount of data missing as an empty string.
+    """
+
+    # Avoid SettingWithCopyWarning
+    column = column.copy()
+    noise_level = configuration.row_noise_level
+    # Get rows to noise
+    to_noise_idx = randomness_stream.filter_for_probability(
+        column.index,
+        probability=noise_level,
+        additional_key=f"{additional_key}_missing_data_filter",
+    )
+    column.loc[to_noise_idx] = ""
+
+    return column
+
+
+def generate_typographical_errors(
+    column: pd.Series,
+    configuration: ConfigTree,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.Series:
+    """
+
+    :param column:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually generate typographical errors
+    return column
+
+
+def generate_ocr_errors(
+    column: pd.Series,
+    configuration: ConfigTree,
+    randomness_stream: RandomnessStream,
+    additional_key: Any,
+) -> pd.Series:
+    """
+
+    :param column:
+    :param configuration:
+    :param randomness_stream:
+    :param additional_key: Key for RandomnessStream
+    :return:
+    """
+    # todo actually generate OCR errors
+    return column
+
+
+# todo add noise functions

pseudopeople/utilities.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import Union
+
+import pandas as pd
+from vivarium.framework.configuration import ConfigTree
+from vivarium.framework.randomness import RandomnessStream
+
+from pseudopeople.entities import Form
+
+
+def get_randomness_stream(form: Form, seed: int) -> RandomnessStream:
+    return RandomnessStream(form.value, lambda: pd.Timestamp("2020-04-01"), seed)
+
+
+def get_configuration(user_yaml_path: Union[Path, str] = None) -> ConfigTree:
+    """
+    Gets a noising configuration ConfigTree, optionally overridden by a user-provided YAML.
+
+    :param user_yaml_path: A path to the YAML file defining user overrides for the defaults
+    :return: a ConfigTree object of the noising configuration
+    """
+    import pseudopeople
+
+    default_config_layers = [
+        "base",
+        "user",
+    ]
+    noising_configuration = ConfigTree(
+        data=Path(pseudopeople.__file__).resolve().parent / "default_configuration.yaml",
+        layers=default_config_layers,
+    )
+    if user_yaml_path:
+        noising_configuration.update(user_yaml_path, layer="user")
+    return noising_configuration

pseudopeople-0.1.0.dist-info/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Institute for Health Metrics and Evaluation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pseudopeople-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: pseudopeople
+Version: 0.1.0
+Summary: pseudopeople is package which adds noise to simulated census-scale data using standard scientific Python tools.
+Home-page: https://github.com/ihmeuw/pseudopeople
+Author: The pseudopeople developers
+Author-email: vivarium.dev@gmail.com
+License: BSD-3-Clause
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Life
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: pyyaml (>=5.1)
+Requires-Dist: vivarium
+Provides-Extra: dev
+Requires-Dist: sphinx (>=4.0) ; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme ; extra == 'dev'
+Requires-Dist: sphinx-click ; extra == 'dev'
+Requires-Dist: IPython ; extra == 'dev'
+Requires-Dist: matplotlib ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: pytest-mock ; extra == 'dev'
+Requires-Dist: ipywidgets ; extra == 'dev'
+Requires-Dist: jupyter ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx (>=4.0) ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: sphinx-click ; extra == 'docs'
+Requires-Dist: IPython ; extra == 'docs'
+Requires-Dist: matplotlib ; extra == 'docs'
+Provides-Extra: interactive
+Requires-Dist: IPython ; extra == 'interactive'
+Requires-Dist: ipywidgets ; extra == 'interactive'
+Requires-Dist: jupyter ; extra == 'interactive'
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-mock ; extra == 'test'
+
+============
+Pseudopeople
+============
+
+Pseudopeople is a package intended to add configurable noise to a simulated
+census-scale data-set written using standard scientific Python tools.
+
+**Pseudopeople requires Python 3.7-3.10 to run**
+
+You can install ``pseudopeople`` from PyPI with pip:
+
+  ``> pip install pseudopeople``
+
+or build it from source with
+
+  ``> git clone https://github.com/ihmeuw/pseudopeople.git``
+
+  ``> cd pseudopeople``
+
+  ``> python setup.py install``
+
+This will make the ``pseudopeople`` library available to python and install a
+command-line executable called ``...`` that you can use to verify your
+installation with
+
+  ``> ... test``

pseudopeople-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pseudopeople/__about__.py,sha256=QAMJhT9idR8fOcV-i3aaSkE0QWCqpaEDMxx4_bUQrlY,547
+pseudopeople/__init__.py,sha256=wnGxaqs2MD1LmLDR41xDf8ImNcN7RVvY416p43AopKc,229
+pseudopeople/default_configuration.yaml,sha256=pm5YDg848k8-FqFABMcnM94NQ3chvuafjgYjXeBnrd4,1303
+pseudopeople/entities.py,sha256=V21mNvmXU1pQGJjkvZFPlyFeyAfDm-RvlqPtd9BP_qQ,3306
+pseudopeople/entity_types.py,sha256=DzM4fsahY-C_IDkaW45IgPj15bbRkMXq6WZLjKSSn4o,1878
+pseudopeople/interface.py,sha256=ECVeDIcwV7cmpiRWoGa7xMZZtkTSP_RsbiKwWjcoruI,1557
+pseudopeople/noise.py,sha256=ouafbkDmYEOUcMan6OuirOIHyNEU9lR66b08j_s3DNw,2603
+pseudopeople/noise_functions.py,sha256=IBYiMZgVvDfzQx_H1SGm7b8NRB1XhC2R-laHK0YVirA,5977
+pseudopeople/utilities.py,sha256=5aDfhcjeMS3Si_23cy74GjB6KG7H7Bh6106NoRrutss,1113
+pseudopeople-0.1.0.dist-info/LICENSE,sha256=denaAWcYGw8Pfw3jqedWwEedv18-1AH9vnRyGAEAcbc,1530
+pseudopeople-0.1.0.dist-info/METADATA,sha256=RGhOecx8FehEC1YcEPioCXkHFXAHCCM3VN7RD-H1t1U,2885
+pseudopeople-0.1.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+pseudopeople-0.1.0.dist-info/top_level.txt,sha256=wnbm1AJWmSOc2-XNvEyovNG4tqmwUBFL3REUFlKV9vY,13
+pseudopeople-0.1.0.dist-info/RECORD,,

pseudopeople-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.40.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pseudopeople-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pseudopeople