acmc.main

  1import argparse
  2import logging
  3from pathlib import Path
  4
  5import acmc
  6from acmc import trud, omop, phen, parse, logging_config as lc
  7
  8# setup logging
  9logger = lc.setup_logger()
 10
 11DEFAULT_WORKSPACE_PATH = Path("./workspace")
 12
 13
 14def trud_install(args: argparse.Namespace):
 15    """Handle the `trud install` command."""
 16    trud.install()
 17
 18
 19def omop_install(args: argparse.Namespace):
 20    """Handle the `omop install` command."""
 21    omop.install(args.omop_zip_file, args.version)
 22
 23
 24def omop_clear(args: argparse.Namespace):
 25    """Handle the `omop clear` command."""
 26    omop.clear(omop.DB_PATH)
 27
 28
 29def omop_delete(args: argparse.Namespace):
 30    """Handle the `omop delete` command."""
 31    omop.delete(omop.DB_PATH)
 32
 33
 34def phen_init(args: argparse.Namespace):
 35    """Handle the `phen init` command."""
 36    phen.init(args.phen_dir, args.remote_url)
 37
 38
 39def phen_fork(args: argparse.Namespace):
 40    """Handle the `phen fork` command."""
 41    phen.fork(
 42        args.phen_dir,
 43        args.upstream_url,
 44        args.upstream_version,
 45        new_origin_url=args.remote_url,
 46    )
 47
 48
 49def phen_validate(args: argparse.Namespace):
 50    """Handle the `phen validate` command."""
 51    phen.validate(args.phen_dir)
 52
 53
 54def phen_map(args: argparse.Namespace):
 55    """Handle the `phen map` command."""
 56    phen.map(args.phen_dir, args.target_coding)
 57
 58
 59def phen_export(args: argparse.Namespace):
 60    """Handle the `phen copy` command."""
 61    phen.export(args.phen_dir, args.version)
 62
 63
 64def phen_publish(args: argparse.Namespace):
 65    """Handle the `phen publish` command."""
 66    phen.publish(args.phen_dir, args.msg, args.remote_url, args.increment)
 67
 68
 69def phen_copy(args: argparse.Namespace):
 70    """Handle the `phen copy` command."""
 71    phen.copy(args.phen_dir, args.target_dir, args.version)
 72
 73
 74def phen_diff(args: argparse.Namespace):
 75    """Handle the `phen diff` command."""
 76    phen.diff(args.phen_dir, args.version, args.old_phen_dir, args.old_version)
 77
 78
 79def main():
 80    parser = argparse.ArgumentParser(description="ACMC command-line tool")
 81    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
 82    parser.add_argument(
 83        "--version", action="version", version=f"acmc {acmc.__version__}"
 84    )
 85
 86    # Top-level commands
 87    subparsers = parser.add_subparsers(
 88        dest="command", required=True, help="Available commands"
 89    )
 90
 91    ### TRUD Command ###
 92    trud_parser = subparsers.add_parser("trud", help="TRUD commands")
 93    trud_subparsers = trud_parser.add_subparsers(
 94        dest="subcommand", required=True, help="TRUD subcommands"
 95    )
 96
 97    # trud install
 98    trud_install_parser = trud_subparsers.add_parser(
 99        "install", help="Install TRUD components"
100    )
101    trud_install_parser.set_defaults(func=trud_install)
102
103    ### OMOP Command ###
104    omop_parser = subparsers.add_parser("omop", help="OMOP commands")
105    omop_subparsers = omop_parser.add_subparsers(
106        dest="subcommand", required=True, help="OMOP subcommands"
107    )
108
109    # omop install
110    omop_install_parser = omop_subparsers.add_parser(
111        "install", help="Install OMOP codes within database"
112    )
113    omop_install_parser.add_argument(
114        "-f", "--omop-zip-file", required=True, help="Path to downloaded OMOP zip file"
115    )
116    omop_install_parser.add_argument(
117        "-v", "--version", required=True, help="OMOP vocabularies release version"
118    )
119    omop_install_parser.set_defaults(func=omop_install)
120
121    # omop clear
122    omop_clear_parser = omop_subparsers.add_parser(
123        "clear", help="Clear OMOP data from database"
124    )
125    omop_clear_parser.set_defaults(func=omop_clear)
126
127    # omop delete
128    omop_delete_parser = omop_subparsers.add_parser(
129        "delete", help="Delete OMOP database"
130    )
131    omop_delete_parser.set_defaults(func=omop_delete)
132
133    ### PHEN Command ###
134    phen_parser = subparsers.add_parser("phen", help="Phen commands")
135    phen_subparsers = phen_parser.add_subparsers(
136        dest="subcommand", required=True, help="Phen subcommands"
137    )
138
139    # phen init
140    phen_init_parser = phen_subparsers.add_parser(
141        "init", help="Initiatise phenotype directory"
142    )
143    phen_init_parser.add_argument(
144        "-d",
145        "--phen-dir",
146        type=str,
147        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
148        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
149    )
150    phen_init_parser.add_argument(
151        "-r",
152        "--remote_url",
153        help="(Optional) URL to repository where the phenotype will be published.",
154    )
155    phen_init_parser.set_defaults(func=phen_init)
156
157    # phen fork
158    phen_fork_parser = phen_subparsers.add_parser(
159        "fork", help="Fork an existing phenotype"
160    )
161    phen_fork_parser.add_argument(
162        "-d",
163        "--phen-dir",
164        type=str,
165        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
166        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
167    )
168    phen_fork_parser.add_argument(
169        "-r",
170        "--remote_url",
171        help="(Optional) URL to repository where the forked phenotype will be published.",
172    )
173    phen_fork_parser.add_argument(
174        "-u",
175        "--upstream-url",
176        required=True,
177        help="(Required) URL to the phenotype repository to fork.",
178    )
179    phen_fork_parser.add_argument(
180        "-v",
181        "--upstream-version",
182        required=True,
183        help="(Required) Phenotype version to fork.",
184    )
185    phen_fork_parser.set_defaults(func=phen_fork)
186
187    # phen validate
188    phen_validate_parser = phen_subparsers.add_parser(
189        "validate", help="Validate phenotype configuration"
190    )
191    phen_validate_parser.add_argument(
192        "-d",
193        "--phen-dir",
194        type=str,
195        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
196        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
197    )
198    phen_validate_parser.set_defaults(func=phen_validate)
199
200    # phen map
201    phen_map_parser = phen_subparsers.add_parser("map", help="Process phen mapping")
202    phen_map_parser.add_argument(
203        "-d",
204        "--phen-dir",
205        type=str,
206        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
207        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
208    )
209    phen_map_parser.add_argument(
210        "-t",
211        "--target-coding",
212        choices=parse.SUPPORTED_CODE_TYPES,
213        help=f"Specify the target coding {parse.SUPPORTED_CODE_TYPES}",
214    )
215    phen_map_parser.set_defaults(func=phen_map)
216
217    # phen export
218    phen_export_parser = phen_subparsers.add_parser(
219        "export", help="Export phen to OMOP database"
220    )
221    phen_export_parser.add_argument(
222        "-d",
223        "--phen-dir",
224        type=str,
225        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
226        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
227    )
228    phen_export_parser.add_argument(
229        "-v",
230        "--version",
231        type=str,
232        default="latest",
233        help="Phenotype version to export, defaults to the latest version",
234    )
235    phen_export_parser.set_defaults(func=phen_export)
236
237    # phen publish
238    phen_publish_parser = phen_subparsers.add_parser(
239        "publish", help="Publish phenotype configuration"
240    )
241    phen_publish_parser.add_argument(
242        "-d",
243        "--phen-dir",
244        type=str,
245        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
246        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
247    )
248    phen_publish_parser.add_argument(
249        "-i",
250        "--increment",
251        type=str,
252        default=phen.DEFAULT_VERSION_INC,
253        choices=phen.SEMANTIC_VERSION_TYPES,
254        help=f"Version increment: {phen.SEMANTIC_VERSION_TYPES}, default is {phen.DEFAULT_VERSION_INC} increment",
255    )
256    phen_publish_parser.add_argument(
257        "-m", "--msg", help="Message to include with the published version"
258    )
259    phen_publish_parser.add_argument(
260        "-r", "--remote_url", help="URL to remote git repository"
261    )
262    phen_publish_parser.set_defaults(func=phen_publish)
263
264    # phen copy
265    phen_copy_parser = phen_subparsers.add_parser(
266        "copy", help="Publish phenotype configuration"
267    )
268    phen_copy_parser.add_argument(
269        "-d",
270        "--phen-dir",
271        type=str,
272        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
273        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
274    )
275    phen_copy_parser.add_argument(
276        "-td",
277        "--target-dir",
278        type=str,
279        default=str(DEFAULT_WORKSPACE_PATH.resolve()),
280        help="Target directory for the copy",
281    )
282    phen_copy_parser.add_argument(
283        "-v",
284        "--version",
285        type=str,
286        default="latest",
287        help="Phenotype version to copy, defaults to the latest version",
288    )
289    phen_copy_parser.set_defaults(func=phen_copy)
290
291    # phen diff
292    phen_diff_parser = phen_subparsers.add_parser(
293        "diff", help="Publish phenotype configuration"
294    )
295    phen_diff_parser.add_argument(
296        "-d",
297        "--phen-dir",
298        type=str,
299        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
300        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
301    )
302    phen_diff_parser.add_argument(
303        "-v",
304        "--version",
305        default="latest",
306        help="Phenotype version to compare with an old version, defaults to the HEAD of the workspace directory",
307    )
308    phen_diff_parser.add_argument(
309        "-od",
310        "--old-phen-dir",
311        type=str,
312        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
313        help="Directory for the old phenotype version, defaults to workspace directory",
314    )
315    phen_diff_parser.add_argument(
316        "-ov",
317        "--old-version",
318        required=True,
319        help="Old phenotype version to compare with the changed version",
320    )
321    phen_diff_parser.set_defaults(func=phen_diff)
322
323    # Parse arguments
324    args = parser.parse_args()
325
326    # setup logging
327    if args.debug:
328        lc.set_log_level(logging.DEBUG)
329
330    # Call the function associated with the command
331    args.func(args)
332
333
334if __name__ == "__main__":
335    main()
logger = <Logger acmc_logger (INFO)>
DEFAULT_WORKSPACE_PATH = PosixPath('workspace')
def trud_install(args: argparse.Namespace):
15def trud_install(args: argparse.Namespace):
16    """Handle the `trud install` command."""
17    trud.install()

Handle the trud install command.

def omop_install(args: argparse.Namespace):
20def omop_install(args: argparse.Namespace):
21    """Handle the `omop install` command."""
22    omop.install(args.omop_zip_file, args.version)

Handle the omop install command.

def omop_clear(args: argparse.Namespace):
25def omop_clear(args: argparse.Namespace):
26    """Handle the `omop clear` command."""
27    omop.clear(omop.DB_PATH)

Handle the omop clear command.

def omop_delete(args: argparse.Namespace):
30def omop_delete(args: argparse.Namespace):
31    """Handle the `omop delete` command."""
32    omop.delete(omop.DB_PATH)

Handle the omop delete command.

def phen_init(args: argparse.Namespace):
35def phen_init(args: argparse.Namespace):
36    """Handle the `phen init` command."""
37    phen.init(args.phen_dir, args.remote_url)

Handle the phen init command.

def phen_fork(args: argparse.Namespace):
40def phen_fork(args: argparse.Namespace):
41    """Handle the `phen fork` command."""
42    phen.fork(
43        args.phen_dir,
44        args.upstream_url,
45        args.upstream_version,
46        new_origin_url=args.remote_url,
47    )

Handle the phen fork command.

def phen_validate(args: argparse.Namespace):
50def phen_validate(args: argparse.Namespace):
51    """Handle the `phen validate` command."""
52    phen.validate(args.phen_dir)

Handle the phen validate command.

def phen_map(args: argparse.Namespace):
55def phen_map(args: argparse.Namespace):
56    """Handle the `phen map` command."""
57    phen.map(args.phen_dir, args.target_coding)

Handle the phen map command.

def phen_export(args: argparse.Namespace):
60def phen_export(args: argparse.Namespace):
61    """Handle the `phen copy` command."""
62    phen.export(args.phen_dir, args.version)

Handle the phen copy command.

def phen_publish(args: argparse.Namespace):
65def phen_publish(args: argparse.Namespace):
66    """Handle the `phen publish` command."""
67    phen.publish(args.phen_dir, args.msg, args.remote_url, args.increment)

Handle the phen publish command.

def phen_copy(args: argparse.Namespace):
70def phen_copy(args: argparse.Namespace):
71    """Handle the `phen copy` command."""
72    phen.copy(args.phen_dir, args.target_dir, args.version)

Handle the phen copy command.

def phen_diff(args: argparse.Namespace):
75def phen_diff(args: argparse.Namespace):
76    """Handle the `phen diff` command."""
77    phen.diff(args.phen_dir, args.version, args.old_phen_dir, args.old_version)

Handle the phen diff command.

def main():
 80def main():
 81    parser = argparse.ArgumentParser(description="ACMC command-line tool")
 82    parser.add_argument("--debug", action="store_true", help="Enable debug mode")
 83    parser.add_argument(
 84        "--version", action="version", version=f"acmc {acmc.__version__}"
 85    )
 86
 87    # Top-level commands
 88    subparsers = parser.add_subparsers(
 89        dest="command", required=True, help="Available commands"
 90    )
 91
 92    ### TRUD Command ###
 93    trud_parser = subparsers.add_parser("trud", help="TRUD commands")
 94    trud_subparsers = trud_parser.add_subparsers(
 95        dest="subcommand", required=True, help="TRUD subcommands"
 96    )
 97
 98    # trud install
 99    trud_install_parser = trud_subparsers.add_parser(
100        "install", help="Install TRUD components"
101    )
102    trud_install_parser.set_defaults(func=trud_install)
103
104    ### OMOP Command ###
105    omop_parser = subparsers.add_parser("omop", help="OMOP commands")
106    omop_subparsers = omop_parser.add_subparsers(
107        dest="subcommand", required=True, help="OMOP subcommands"
108    )
109
110    # omop install
111    omop_install_parser = omop_subparsers.add_parser(
112        "install", help="Install OMOP codes within database"
113    )
114    omop_install_parser.add_argument(
115        "-f", "--omop-zip-file", required=True, help="Path to downloaded OMOP zip file"
116    )
117    omop_install_parser.add_argument(
118        "-v", "--version", required=True, help="OMOP vocabularies release version"
119    )
120    omop_install_parser.set_defaults(func=omop_install)
121
122    # omop clear
123    omop_clear_parser = omop_subparsers.add_parser(
124        "clear", help="Clear OMOP data from database"
125    )
126    omop_clear_parser.set_defaults(func=omop_clear)
127
128    # omop delete
129    omop_delete_parser = omop_subparsers.add_parser(
130        "delete", help="Delete OMOP database"
131    )
132    omop_delete_parser.set_defaults(func=omop_delete)
133
134    ### PHEN Command ###
135    phen_parser = subparsers.add_parser("phen", help="Phen commands")
136    phen_subparsers = phen_parser.add_subparsers(
137        dest="subcommand", required=True, help="Phen subcommands"
138    )
139
140    # phen init
141    phen_init_parser = phen_subparsers.add_parser(
142        "init", help="Initiatise phenotype directory"
143    )
144    phen_init_parser.add_argument(
145        "-d",
146        "--phen-dir",
147        type=str,
148        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
149        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
150    )
151    phen_init_parser.add_argument(
152        "-r",
153        "--remote_url",
154        help="(Optional) URL to repository where the phenotype will be published.",
155    )
156    phen_init_parser.set_defaults(func=phen_init)
157
158    # phen fork
159    phen_fork_parser = phen_subparsers.add_parser(
160        "fork", help="Fork an existing phenotype"
161    )
162    phen_fork_parser.add_argument(
163        "-d",
164        "--phen-dir",
165        type=str,
166        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
167        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
168    )
169    phen_fork_parser.add_argument(
170        "-r",
171        "--remote_url",
172        help="(Optional) URL to repository where the forked phenotype will be published.",
173    )
174    phen_fork_parser.add_argument(
175        "-u",
176        "--upstream-url",
177        required=True,
178        help="(Required) URL to the phenotype repository to fork.",
179    )
180    phen_fork_parser.add_argument(
181        "-v",
182        "--upstream-version",
183        required=True,
184        help="(Required) Phenotype version to fork.",
185    )
186    phen_fork_parser.set_defaults(func=phen_fork)
187
188    # phen validate
189    phen_validate_parser = phen_subparsers.add_parser(
190        "validate", help="Validate phenotype configuration"
191    )
192    phen_validate_parser.add_argument(
193        "-d",
194        "--phen-dir",
195        type=str,
196        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
197        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
198    )
199    phen_validate_parser.set_defaults(func=phen_validate)
200
201    # phen map
202    phen_map_parser = phen_subparsers.add_parser("map", help="Process phen mapping")
203    phen_map_parser.add_argument(
204        "-d",
205        "--phen-dir",
206        type=str,
207        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
208        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
209    )
210    phen_map_parser.add_argument(
211        "-t",
212        "--target-coding",
213        choices=parse.SUPPORTED_CODE_TYPES,
214        help=f"Specify the target coding {parse.SUPPORTED_CODE_TYPES}",
215    )
216    phen_map_parser.set_defaults(func=phen_map)
217
218    # phen export
219    phen_export_parser = phen_subparsers.add_parser(
220        "export", help="Export phen to OMOP database"
221    )
222    phen_export_parser.add_argument(
223        "-d",
224        "--phen-dir",
225        type=str,
226        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
227        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
228    )
229    phen_export_parser.add_argument(
230        "-v",
231        "--version",
232        type=str,
233        default="latest",
234        help="Phenotype version to export, defaults to the latest version",
235    )
236    phen_export_parser.set_defaults(func=phen_export)
237
238    # phen publish
239    phen_publish_parser = phen_subparsers.add_parser(
240        "publish", help="Publish phenotype configuration"
241    )
242    phen_publish_parser.add_argument(
243        "-d",
244        "--phen-dir",
245        type=str,
246        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
247        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
248    )
249    phen_publish_parser.add_argument(
250        "-i",
251        "--increment",
252        type=str,
253        default=phen.DEFAULT_VERSION_INC,
254        choices=phen.SEMANTIC_VERSION_TYPES,
255        help=f"Version increment: {phen.SEMANTIC_VERSION_TYPES}, default is {phen.DEFAULT_VERSION_INC} increment",
256    )
257    phen_publish_parser.add_argument(
258        "-m", "--msg", help="Message to include with the published version"
259    )
260    phen_publish_parser.add_argument(
261        "-r", "--remote_url", help="URL to remote git repository"
262    )
263    phen_publish_parser.set_defaults(func=phen_publish)
264
265    # phen copy
266    phen_copy_parser = phen_subparsers.add_parser(
267        "copy", help="Publish phenotype configuration"
268    )
269    phen_copy_parser.add_argument(
270        "-d",
271        "--phen-dir",
272        type=str,
273        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
274        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
275    )
276    phen_copy_parser.add_argument(
277        "-td",
278        "--target-dir",
279        type=str,
280        default=str(DEFAULT_WORKSPACE_PATH.resolve()),
281        help="Target directory for the copy",
282    )
283    phen_copy_parser.add_argument(
284        "-v",
285        "--version",
286        type=str,
287        default="latest",
288        help="Phenotype version to copy, defaults to the latest version",
289    )
290    phen_copy_parser.set_defaults(func=phen_copy)
291
292    # phen diff
293    phen_diff_parser = phen_subparsers.add_parser(
294        "diff", help="Publish phenotype configuration"
295    )
296    phen_diff_parser.add_argument(
297        "-d",
298        "--phen-dir",
299        type=str,
300        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
301        help="(Optional) Local phenotype workspace directory (default is ./workspace/phen).",
302    )
303    phen_diff_parser.add_argument(
304        "-v",
305        "--version",
306        default="latest",
307        help="Phenotype version to compare with an old version, defaults to the HEAD of the workspace directory",
308    )
309    phen_diff_parser.add_argument(
310        "-od",
311        "--old-phen-dir",
312        type=str,
313        default=str(phen.DEFAULT_PHEN_PATH.resolve()),
314        help="Directory for the old phenotype version, defaults to workspace directory",
315    )
316    phen_diff_parser.add_argument(
317        "-ov",
318        "--old-version",
319        required=True,
320        help="Old phenotype version to compare with the changed version",
321    )
322    phen_diff_parser.set_defaults(func=phen_diff)
323
324    # Parse arguments
325    args = parser.parse_args()
326
327    # setup logging
328    if args.debug:
329        lc.set_log_level(logging.DEBUG)
330
331    # Call the function associated with the command
332    args.func(args)