redcap-toolbox 2025.7.9__py2.py3-none-any.whl

redcap_toolbox/__init__.py

@@ -0,0 +1,4 @@
+# Copyright 2023 Board of Regents of the University of Wisconsin System
+# Written by Nate Vack <njvack@wisc.edu>, Nicholas Vanhaute <nvanhaute@wisc.edu>, and
+# Stuti Shrivastava <sshrivastav6@wisc.edu>
+# Source is available at https://github.com/uwmadison-chm/redcap-tools

redcap_toolbox/download_redcap.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+"""
+Download the data for a REDCap study to a CSV files. Optionally takes a
+filename with a list of forms to skip from the download, one per line.
+
+Relies on the environment variables REDCAP_API_URL and REDCAP_API_TOKEN.
+
+Written by Nate Vack <njvack@wisc.edu> and Dan Fitch <dfitch@wisc.edu>
+
+Usage:
+  download_redcap.py [options] <output_file>
+
+Options:
+  -h --help        Show this screen.
+  --forms=<file>   A file containing a list of forms to download, one per line;
+                   if not specified, download all forms.
+  --survey-fields  Include survey timestamps in output
+  -d --debug       Print debugging output
+"""
+
+import logging
+import os
+from pathlib import Path
+
+import redcap
+from docopt import docopt
+
+logging.basicConfig(format="%(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+API_URL = os.environ["REDCAP_API_URL"]
+API_TOK = os.environ["REDCAP_API_TOKEN"]
+PROJ = redcap.Project(API_URL, API_TOK)
+
+
+def file_to_list(filename):
+    out = []
+    with open(filename) as f:
+        out = [line.strip() for line in f.readlines()]
+    return out
+
+
+def download_redcap(out_file, form_list_file, export_survey_fields):
+    forms = None
+    if form_list_file:
+        forms = file_to_list(form_list_file)
+    logger.debug(f"Instruments: {forms}")
+    data = PROJ.export_records(
+        format_type="csv", forms=forms, export_survey_fields=export_survey_fields
+    )
+    with open(out_file, "w", encoding="utf8") as f:
+        f.write(data)
+
+
+def main():
+    args = docopt(__doc__)
+    if args["--debug"]:
+        logger.setLevel(logging.DEBUG)
+    logger.debug(args)
+    download_redcap(
+        Path(args["<output_file>"]), args["--forms"], args["--survey-fields"]
+    )
+
+
+if __name__ == "__main__":
+    main()

redcap_toolbox/download_redcap_report.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+
+"""
+Download the reports in a REDCap study to a CSV files. Takes in either a CSV
+file with a list of report IDs, one per line, or a list of report IDs seperated
+by commas.
+
+If your report IDs look like: 32001, 32004 with no prefix provided, the output report filenames
+will look like this in the output directory:
+redcap__report_32001.csv
+redcap__report_32004.csv
+
+Relies on the environment variables REDCAP_API_URL and REDCAP_API_TOKEN.
+
+Written by Stuti Shrivastava <sshrivastav6@wisc.edu>
+
+Usage:
+  download_redcap_report.py [options] ([--id=<id>]... | [--file=<file>]) <output_dir>
+  download_redcap_report.py -h | --help
+
+Options:
+  -h --help            Show this screen.
+  -d --debug           Print debugging output
+  --file=<file>        A file containing a list of report IDs, one per line
+  --id=<id>            A list of report IDs separated by commas
+  --prefix=<prefix>    A filename prefix for the output [default: redcap]
+
+"""
+
+import logging
+import os
+import traceback
+from pathlib import Path
+
+import redcap
+from docopt import docopt
+from requests import RequestException
+
+logging.basicConfig(format="%(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+API_URL = os.environ["REDCAP_API_URL"]
+API_TOK = os.environ["REDCAP_API_TOKEN"]
+PROJ = redcap.Project(API_URL, API_TOK)
+
+
+def file_to_list(filename):
+    out = []
+    with open(filename) as f:
+        out = [line.strip() for line in f.readlines()]
+    out = [str(rep_id) for rep_id in out if rep_id != ""]
+    return out
+
+
+def download_redcap_report(
+    report_ids: list[str], out_dir: Path, prefix: str, verbose: bool
+) -> None:
+    for rep_id in report_ids:
+        logger.debug(f"Downloading report for record ID: {rep_id}")
+        try:
+            data = PROJ.export_report(report_id=rep_id, format_type="csv")
+            out_file = Path(out_dir).joinpath(f"{prefix}__report_{rep_id}.csv")
+            with open(out_file, "w", encoding="utf8") as f:
+                f.write(data)
+                logger.info(f"Report {rep_id} downloaded to {out_file}")
+        except RequestException as e:
+            logger.warning(e)
+            logger.warning(f"Report {rep_id} not found! Skipping ...")
+            if verbose:
+                logger.warning(traceback.format_exc())
+
+
+def main():
+    args = docopt(__doc__)
+    if args["--debug"]:
+        logger.setLevel(logging.DEBUG)
+    logger.debug(args)
+
+    out_dir = Path(args["<output_dir>"])
+    if not out_dir.is_dir():
+        logger.warning(
+            f"Output directory {out_dir} does not exist! Making directory ..."
+        )
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+    if args["--file"]:
+        report_ids = file_to_list(args["--file"])
+    elif args["--id"]:
+        report_ids = [str(rep_id) for rep_id in args["--id"]]
+    else:
+        raise ValueError("No report IDs provided!")
+    logger.debug(f"Report IDs: {report_ids}")
+    if len(report_ids) == 0:
+        raise ValueError(
+            f"No report IDs provided! {report_ids}. Provide either --id or --file."
+        )
+
+    download_redcap_report(report_ids, out_dir, args["--prefix"], args["--debug"])
+
+
+if __name__ == "__main__":
+    main()

redcap_toolbox/minchange.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+
+"""
+A function to return a dict with the minimal changes to transform
+one dataframe to another (identically-shaped) dataframe.
+"""
+
+from collections.abc import Iterable
+
+
+def transformation_dicts(source_df, target_df, allow_new=False):
+    """
+    Calculates the minimal set of changes to transform source_df into target_df.
+    source_df and target_df must be identically-shaped -- in particular,
+    source_df.index must equal target_df.index, and source_df.columns must equal
+    target_df.columns.
+
+    Each dict looks like:
+    {
+            "index_name_1": index_value_1,
+            ...
+            "index_name_n": index_value_n,
+            "column_name_1": new_value_1,
+            ...
+            "column_name_n": new_value_n
+    }
+    Rows that have no changes are not included.
+    """
+    # Validate index formats match
+    if not _index_formats_match(source_df, target_df):
+        raise ValueError("Index formats do not match")
+
+    # Check columns match
+    if not source_df.columns.equals(target_df.columns):
+        raise ValueError("Source and target dfs have different columns")
+
+    # Handle different cases based on allow_new
+    if allow_new:
+        return _handle_with_new_rows(source_df, target_df)
+    else:
+        # Original behavior - indexes must be identical
+        if not source_df.index.equals(target_df.index):
+            raise ValueError("Source and target dfs have different indexes")
+        diff = source_df.ne(target_df)
+        return [
+            d
+            for (idx, vals) in diff.iterrows()
+            if (d := diff_dict(idx, vals, target_df))
+        ]
+
+
+def _index_formats_match(source_df, target_df):
+    """Check if index formats match (same names and number of levels)."""
+    return source_df.index.names == target_df.index.names and len(
+        source_df.index.names
+    ) == len(target_df.index.names)
+
+
+def _handle_with_new_rows(source_df, target_df):
+    """Handle transformation when new rows are allowed."""
+    results = []
+
+    # Handle existing rows (rows in both source and target)
+    common_idx = source_df.index.intersection(target_df.index)
+    if len(common_idx) > 0:
+        source_common = source_df.loc[common_idx]
+        target_common = target_df.loc[common_idx]
+        diff = source_common.ne(target_common)
+        results.extend(
+            [
+                d
+                for (idx, vals) in diff.iterrows()
+                if (d := diff_dict(idx, vals, target_df))
+            ]
+        )
+
+    # Handle new rows (rows in target but not in source)
+    new_idx = target_df.index.difference(source_df.index)
+    if len(new_idx) > 0:
+        new_rows = target_df.loc[new_idx]
+        for idx, row in new_rows.iterrows():
+            new_row_dict = _create_new_row_dict(idx, row, target_df)
+            if new_row_dict:
+                results.append(new_row_dict)
+
+    return results
+
+
+def _create_new_row_dict(idx, row, target_df):
+    """Create dictionary for new row, filtering out blank columns."""
+    if not isinstance(idx, Iterable) or isinstance(idx, str):
+        idx = (idx,)
+
+    # Start with index
+    result = dict(zip(target_df.index.names, idx))
+
+    # Add non-blank columns
+    for col_name, value in row.items():
+        if value != "" and str(value) != "nan":
+            result[col_name] = value
+
+    # Always return the dict (even if only index) - this handles the case
+    # where all columns are blank but we still want to include the index
+    return result
+
+
+def diff_dict(idx, vals, target_df):
+    if not isinstance(idx, Iterable) or isinstance(idx, str):
+        idx = (idx,)
+    true_indexes = vals[vals].index
+    if len(true_indexes) == 0:
+        return None
+    return (
+        dict(zip(target_df.index.names, idx))
+        | target_df.loc[idx, true_indexes].to_dict()
+    )

redcap_toolbox/split_redcap_data.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+
+"""
+Takes a REDCap CSV file and splits it into:
+
+* A file for each event
+* A file for repeated instruments in events where they happen
+
+So, if your data has events 'scr,' 'pre,' and 'post', and 'pre' and 'post'
+each have a repeated instrument called 'meds', you can expect
+
+redcap__scr.csv
+redcap__pre.csv
+redcap__pre__meds.csv
+redcap__post.csv
+redcap__post__meds.csv
+
+In addition, if you don't like the whole _arm_1 appended to your event names
+(who does like that?) or you're using events to denote arms and want all your
+event's data together, you can use the event_map file for this. That file
+should be a CSV file and contain the columns 'redcap_event' and 'filename_event'
+
+Example event maps might look like:
+scr__all_arm_1,scr
+pre__control_arm_1,pre
+pre__intervention_arm_1,pre
+
+Usage:
+  split_redcap_data.py [options] <input_file> <output_directory>
+
+Options:
+  --event-map=<event_file>  A file mapping redcap events to file events
+  --prefix=<prefix>         A filename prefix for the output [default: redcap]
+  --no-condense             Don't filter empty rows, columns and files
+  -h --help                 Show this screen
+  -d --debug                Print debugging output
+"""
+
+import logging
+from collections import defaultdict
+from pathlib import Path
+
+import docopt
+import pandas as pd
+
+logging.basicConfig(format="%(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+def make_event_map(mapping_file):
+    if mapping_file is None:
+        return {}
+    map_df = pd.read_csv(mapping_file, index_col="redcap_event", dtype=str)
+    event_map = map_df["filename_event"].to_dict()
+    return event_map
+
+
+def combine_names(event_name, rep_name):
+    parts = [name for name in [event_name, rep_name] if name != ""]
+    joined = "__".join(parts)
+    logger.debug(f"Made name {joined} from {event_name} and {rep_name}")
+    return joined
+
+
+def split_data(data, event_map):
+    """
+    Returns a dict of nonprefixed_filename: data pairs
+    """
+    data_lists = defaultdict(list)
+    index_col = data.columns[0]
+    event_groups = data.groupby(by="redcap_event_name")
+    for rc_event, event_data in event_groups:
+        out_event_name = event_map.get(rc_event, rc_event)
+        rep_groups = event_data.groupby(by="redcap_repeat_instrument")
+        for rep_group, rep_data in rep_groups:
+            out_name = combine_names(out_event_name, rep_group)
+            data_lists[out_name].append(rep_data)
+    # Now, we need to concat the dataframes and sort them by the index column
+    dataframes = {
+        name: pd.concat(df_list).sort_values(by=index_col)
+        for name, df_list in data_lists.items()
+    }
+    for name, df in dataframes.items():
+        logger.debug(f"Name: {name}, Shape: {df.shape})")
+    return dataframes
+
+
+def condense_df(df, condense_rows=True, condense_cols=True):
+    """
+    Drop any rows and columns with only blank values
+    This is not a super great way to do this, as it means the shape of the data we write
+    (columns in particular) will depend on the content of the data.
+    A better way to do this would be to make a list of what columns should appear in
+    which events using the API and filter using that list. That's not so simple, though.
+    """
+    index_col = df.columns[0]
+    reserved_cols = {
+        index_col,
+        "redcap_event_name",
+        "redcap_repeat_instrument",
+        "redcap_repeat_instance",
+    }
+    rowdrop_cols = list(set(df.columns) - reserved_cols)
+    
+    df_rows_cleaned = df
+    if condense_rows:
+      df_rows_cleaned = df[~(df[rowdrop_cols] == "").all(axis=1)]
+    cols_to_keep = df.columns
+    if condense_cols:
+      cols_to_keep = cols_to_keep = ~(df_rows_cleaned == "").all(axis=0)
+
+    return df_rows_cleaned.loc[:, cols_to_keep].copy()
+
+
+def split_redcap_data(
+    input_file, output_directory, prefix="redcap", mapping_file=None, condense=True
+):
+    event_map = make_event_map(mapping_file)
+    logger.debug(f"Event map: {event_map}")
+    data = pd.read_csv(input_file, index_col=None, dtype=str, na_filter=False)
+    # Make sure the event and repeating columns are present, so we can process
+    # the data the same in all cases.
+    if "redcap_event_name" not in data.columns:
+        logger.debug("Single event file, adding event column")
+        data["redcap_event_name"] = ""
+    if "redcap_repeat_instrument" not in data.columns:
+        data["redcap_repeat_instrument"] = ""
+        data["redcap_repeat_instance"] = ""
+        logger.debug("Non-repeating file, added repeat columns")
+    named_dataframes = split_data(data, event_map)
+    logger.debug(named_dataframes)
+    for name, df in named_dataframes.items():
+        if condense:
+            df = condense_df(df)
+        file_base = combine_names(prefix, name)
+        filename = f"{file_base}.csv"
+        out_path = Path(output_directory) / filename
+        logger.info(f"Saving dataframe with shape {df.shape} to {out_path}")
+        df.to_csv(out_path, index=False)
+
+
+def main():
+    args = docopt.docopt(__doc__)
+    if args["--debug"]:
+        logger.setLevel(logging.DEBUG)
+    logger.debug(args)
+    split_redcap_data(
+        Path(args["<input_file>"]),
+        Path(args["<output_directory>"]),
+        args["--prefix"],
+        args["--event-map"],
+        not args["--no-condense"],
+    )
+
+
+if __name__ == "__main__":
+    main()

redcap_toolbox/update_redcap_diff.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+
+"""
+Update a REDCap database with the minimum changes needed to make the system in
+sync.
+
+Requires the following environment variables to be set:
+REDCAP_API_URL
+REDCAP_API_TOKEN
+
+Usage: update_redcap_diff.py [options] <base_csv> <updated_csv>
+
+Options:
+    --allow-new   Allow adding new rows to REDCap.
+    --dry-run     Don't actually make changes.
+    -h --help     Show this screen.
+    -v --verbose  Show debug logging.
+"""
+
+import logging
+import os
+import sys
+
+import docopt
+import pandas as pd
+import redcap
+import redcap_toolbox.minchange
+
+logging.basicConfig(format="%(message)s")
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# Initialize these as None - they'll be set in main()
+API_URL = None
+API_TOK = None
+PROJ = None
+
+
+def update_redcap_diff(base_csv, updated_csv, dry_run, allow_new=False):
+    base_df = pd.read_csv(
+        base_csv, dtype=str, na_values=["nan", "NaN"], keep_default_na=False
+    )
+    index_cols = [base_df.columns[0]]
+    if "redcap_event_name" in base_df.columns:
+        index_cols.append("redcap_event_name")
+    base_df.set_index(index_cols, inplace=True)
+    logger.debug(f"Using index: {index_cols}")
+    updated_df = pd.read_csv(
+        updated_csv, dtype=str, na_values=["nan", "NaN"], keep_default_na=False
+    )
+    updated_df.set_index(index_cols, inplace=True)
+
+    diffs = redcap_toolbox.minchange.transformation_dicts(
+        base_df, updated_df, allow_new=allow_new
+    )
+    if len(diffs) == 0:
+        logger.info("No changes to make")
+        return
+    logger.debug(f"Diffs: {diffs}")
+
+    if dry_run:
+        logger.warning("DRY RUN, NOT UPDATING ANYTHING")
+        logger.warning(f"First change would have been {diffs[0]}")
+    else:
+        result = PROJ.import_records(diffs)
+        logger.info(f"Import record result: {result}")
+
+
+def main():
+    global API_URL, API_TOK, PROJ
+
+    # Initialize API connection
+    try:
+        API_URL = os.environ["REDCAP_API_URL"]
+        API_TOK = os.environ["REDCAP_API_TOKEN"]
+    except KeyError:
+        logger.error("REDCAP_API_URL and REDCAP_API_TOKEN must both be set!")
+        sys.exit(1)
+    PROJ = redcap.Project(API_URL, API_TOK)
+
+    args = docopt.docopt(__doc__)
+    if args["--verbose"]:
+        logger.setLevel(logging.DEBUG)
+    logger.debug(args)
+    update_redcap_diff(
+        args["<base_csv>"],
+        args["<updated_csv>"],
+        args["--dry-run"],
+        args["--allow-new"],
+    )
+
+
+if __name__ == "__main__":
+    main()

redcap_toolbox-2025.7.9.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: redcap_toolbox
+Version: 2025.7.9
+Summary: A collection of tools to interact with the REDCap API
+Project-URL: Homepage, https://github.com/uwmadison-chm/redcap-toolbox
+Project-URL: Issues, https://github.com/uwmadison-chm/redcap-toolbox/issues
+Author-email: Nate Vack <njvack@wisc.edu>
+Maintainer-email: Nate Vack <njvack@wisc.edu>, Nicholas Vanhaute <nvanhaute@wisc.edu>, Stuti Shrivastava <sshrivastav6@wisc.edu>
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: docopt-ng>=0.9.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pycap>=2.6.0
+Description-Content-Type: text/markdown
+
+# redcap-toolbox
+
+Python package of REDCap tools
+
+## Background
+
+The goal of `redcap-toolbox` is to provide researchers with the tools to download and upload data to existing REDCap
+builds. One key aspect of this toolbox is that the minimum number of changes needed to the records are calculated prior
+to importing data in to REDCap, thereby reducing the API load.
+
+## Installing REDCap Toolbox and Supported Versions
+
+redcap-toolbox is available on PyPI:
+
+```console
+$ pip install redcap-toolbox
+```
+
+redcap-toolbox officially supports Python 3.8+.
+
+## Getting started
+
+`redcap-toolbox` relies on the environmental variables `REDCAP_API_URL` and `REDCAP_API_TOKEN`.
+
+### Downloading data
+
+* Download REDCap dataset using `download_redcap` and provide an output file name. By default, all forms are exported.
+* If you want to include survey timestamps, add the optional flag: `--survey-fields`
+* To download specific instrument forms, enter form names to export in a text file, one per line. If in the web UI, the
+  form name has a space in it, replace the space with an underscore. Then, provide that file using the optional flag:
+  `--forms get_forms.csv`
+
+An example call might look like this:
+
+`download_redcap --survey-fields --forms get_forms.csv source_data/full_data.csv`
+
+which will download the data set with only the forms defined in the `get_forms.csv` with timestamps
+
+### Downloading reports
+
+* Reports can be downloaded using `download_redcap_report` with either a list of report IDs separated by commas or a
+  file with list of report IDs, one per line.
+* Use the `--prefix` flag, to specify the prefix to be added for the filenames. Default is `redcap`.
+
+An example call might look like this:
+
+`download_redcap_report --file report_ids.csv --prefix StudyName report_data`
+
+or
+
+`download_redcap_report --id 32001,32004 --prefix StudyName report_data`
+
+which will save all the reports for IDs listed in the `report_ids.csv` file in the `report_data` directory.
+
+* The output report filenames will look like this:
+  ```
+  report_data
+  ├── StudyName__report_32001.csv
+  └── StudyName__report_32004.csv
+  ```
+
+### Splitting REDCap data into event files
+
+* Use `split_redcap_data` to split the REDCap CSV file into:
+    * A file for each event
+    * A file for repeated instruments in events where they happen
+
+* So, if your data has events 'scr', 'pre', and 'post', and 'pre' and 'post'
+  each have a repeated instrument called 'meds', you can expect the output files to like this:
+  ```
+  ├── redcap__scr.csv
+  ├── redcap__pre.csv
+  ├── redcap__pre__meds.csv
+  ├── redcap__post.csv
+  ├── redcap__post.csv
+  └── redcap__post__meds.csv
+  ```
+
+* In addition, if you don't like the whole _arm_1 appended to your event names
+  (who does like that?) or you're using events to denote arms and want all your
+  event's data together, you can use the event_map file for this. That file
+  should be a CSV file and contain the columns 'redcap_event' and 'filename_event'
+
+    * Example event maps might look like:
+      ```
+      scr__all_arm_1,scr
+      pre__control_arm_1,pre
+      pre__intervention_arm_1,pre
+      ```
+
+An example call might look like this:
+
+`split_redcap_data --event-map=event_map.csv --prefix StudyName --no-condense source_data/full_data.csv source_data`
+
+where the split event files will be saved in the `source_data` directory as well with the prefix `StudyName` added to
+them.
+
+```
+source_data
+├── full_data.csv
+├── StudyName__scr.csv
+├── StudyName__pre.csv
+├── StudyName__pre_meds.csv
+├── StudyName__post.csv
+└── StudyName__post_meds.csv
+```
+
+### Update records in REDCap
+
+* Update the REDCap database with the minimum changes needed to make the system in sync.
+* It is important that the updated data file has the same number of rows and columns as the original data file.
+* This functionality is especially useful when updating the record information for Tracking purposes.
+
+An example call might look like this:
+
+`update_redcap_diff StudyName__scr.csv StudyName__scr_cache.csv`
+
+where the `_cache.csv` file contains the changes made to the original data file.
+
+## Credits
+
+`redcap-toolbox` was written by Nate Vack <njvack@wisc.edu>, with features added by Nicholas
+Vanhaute <nvanhaute@wisc.edu> and Stuti Shrivastava <sshrivastav6@wisc.edu>.
+`redcap-toolbox` is copyright 2023 by the Boards of Regents of the University of Wisconsin System.

redcap_toolbox-2025.7.9.dist-info/RECORD

@@ -0,0 +1,11 @@
+redcap_toolbox/__init__.py,sha256=lCVOluSc2Sm6jtqpoboZP3cSNa2tKmX3DkV1C5nMNJg,273
+redcap_toolbox/download_redcap.py,sha256=49eE1gR6s1K11dw-oYkmg7jhpN1ZE5Sw1MSi-5Hpe64,1784
+redcap_toolbox/download_redcap_report.py,sha256=LQd0a1XW9U4C8Oclo92f97LGKbU-HSoGnL_kxoZZBus,3203
+redcap_toolbox/minchange.py,sha256=OqFVutzzpvpgv771mzs9krpU9FOZfWU4dOHGsqc2It8,3815
+redcap_toolbox/split_redcap_data.py,sha256=9FDEw2SGH7g9vMulPwjnCSL3-f5o6c-c8211025R9c8,5361
+redcap_toolbox/update_redcap_diff.py,sha256=kkAKZsfzkDtOsFFdTrE97_WZxEnpNTGqnJ0y-EgHjfU,2495
+redcap_toolbox-2025.7.9.dist-info/METADATA,sha256=WywoN7tcEX7O7BsLUuMyknbyh0tAdnwnez8pCsqJU1I,5344
+redcap_toolbox-2025.7.9.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+redcap_toolbox-2025.7.9.dist-info/entry_points.txt,sha256=2E1RlSqV_WZjmAD6y9kY7at8o2sobmZ3CTcs5X-SnAo,258
+redcap_toolbox-2025.7.9.dist-info/licenses/LICENSE,sha256=IzENQQtGRTcLpRjPl-4CgjxbkNlGuVIqxqBtATqwwsY,1081
+redcap_toolbox-2025.7.9.dist-info/RECORD,,

redcap_toolbox-2025.7.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

redcap_toolbox-2025.7.9.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+download_redcap = redcap_toolbox.download_redcap:main
+download_redcap_report = redcap_toolbox.download_redcap_report:main
+split_redcap_data = redcap_toolbox.split_redcap_data:main
+update_redcap_diff = redcap_toolbox.update_redcap_diff:main

redcap_toolbox-2025.7.9.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Center for Healthy Minds
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.