csvpath 0.0.504__tar.gz → 0.0.506__tar.gz

{csvpath-0.0.504 → csvpath-0.0.506}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: csvpath
-Version: 0.0.504
-Summary: A declarative language for validating CSV, Excel, and other tabular data files
+Version: 0.0.506
+Summary: An edge governance framework for managing and validating CSV, Excel, and other tabular data files
 Author: David Kershaw
 Author-email: dk107dk@hotmail.com
 Requires-Python: >=3.9,<4.0
@@ -33,6 +33,7 @@ Requires-Dist: lark (>=1.2.2,<2.0.0)
 Requires-Dist: marquez-python (>=0.50.0,<0.51.0)
 Requires-Dist: metaphone (>=0.6,<0.7)
 Requires-Dist: openlineage-python (>=1.25.0,<2.0.0)
+Requires-Dist: paramiko (>=3.5.0,<4.0.0)
 Requires-Dist: ply (>=3.11,<4.0)
 Requires-Dist: pylightxl (>=1.61,<2.0)
 Requires-Dist: pytest (>=8.3.3,<9.0.0)

{csvpath-0.0.504 → csvpath-0.0.506}/config/config.ini

@@ -26,12 +26,18 @@ imports = config/functions.imports
 
 [listeners]
 groups =
-#slack, marquez, ckan
+#slack, marquez, ckan, sftp, sftpplus
+
+# add sftpplus to the list of groups above to automate registration and named-paths group runs on file arrival at an SFTPPlus server
+sftpplus.paths = from csvpath.managers.integrations.sftpplus.sftpplus_listener import SftpPlusListener
+
+# add sftp to the list of groups above to push results to an sftp account
+sftp.results = from csvpath.managers.integrations.sftp.sftp_listener import SftpListener
 
 # add ckan to the list of groups above for alerts to slack webhooks
 ckan.results = from csvpath.managers.integrations.ckan.ckan_listener import CkanListener
 
-#add marquez to the list of groups above for OpenLineage events to a local Marquez
+#add marquez to the list of groups above for OpenLineage events to a Marquez server
 marquez.file = from csvpath.managers.integrations.ol.file_listener_ol import OpenLineageFileListener
 marquez.paths = from csvpath.managers.integrations.ol.paths_listener_ol import OpenLineagePathsListener
 marquez.result = from csvpath.managers.integrations.ol.result_listener_ol import OpenLineageResultListener
@@ -43,6 +49,12 @@ slack.paths = from csvpath.managers.integrations.slack.sender import SlackSender
 slack.result = from csvpath.managers.integrations.slack.sender import SlackSender
 slack.results = from csvpath.managers.integrations.slack.sender import SlackSender
 
+[sftpplus]
+admin_user = SFTPPLUS_ADMIN_USERNAME
+admin_password = SFTPPLUS_ADMIN_PASSWORD
+server = SFTPPLUS_SERVER
+port = SFTPPLUS_PORT
+
 [ckan]
 server = http://localhost:80
 api_token = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI3akJwc1ZuSkVrZm1aNnBtVTJfTW5CNlJXZ211YjdOOHVXZ1l1cUFDa0Q4IiwiaWF0IjoxNzM0NzE4NDQ3fQ.QXWXoJoSxVES4NwXYBteYUD7enX9D5T2htmETLGFzrs

csvpath-0.0.506/csvpath/managers/integrations/sftp/sftp_sender.py

@@ -0,0 +1,124 @@
+import threading
+import paramiko
+from csvpath.managers.metadata import Metadata
+from csvpath.managers.results.results_metadata import ResultsMetadata
+from csvpath.managers.results.results_registrar import ResultsRegistrar
+from csvpath.managers.results.result import Result
+from csvpath.managers.listener import Listener
+from csvpath.util.nos import Nos
+from csvpath.util.var_utility import VarUtility
+
+
+#
+# this class is for sending results to an SFTP location. it also run on
+# result updates, but for now we'll just do results updates and loop over
+# all the results.
+#
+#   sftp metadata fields and values are like e.g.:
+#      sftp-server: localhost
+#      sftp-port: 22
+#      sftp-user: LOCAL_SFTP_USER
+#      sftp-password: LOCAL_SFTP_PASSWORD
+#      sftp-target-path: my_data/
+#      sftp-files: data.csv > data.csv, unmatched.csv > var|unmatched_filename, errors.json > errors.json
+#      sftp-original-data: send
+#
+class SftpSender(Listener, threading.Thread):
+    def __init__(self, *, config=None):
+        super().__init__(config)
+        self._server = None
+        self._port = None
+        self._user = None
+        self._password = None
+        self._target_path = None
+        self._files = []
+        self._send_original = False
+        self.csvpaths = None
+        self.result = None
+        self.metadata = None
+        self.results = None
+
+    def _collect_fields(self) -> None:
+        self._server = VarUtility.get_str(self.result, "sftp-server")
+        self._port = VarUtility.get_int(self.result, "sftp-port")
+        self._user = VarUtility.get_str(self.result, "sftp-user")
+        self._password = VarUtility.get_str(self.result, "sftp-password")
+        self._target_path = VarUtility.get_str(self.result, "sftp-target-path")
+        self._original = VarUtility.get_bool(self.result, "sftp-original-data")
+        self._files = VarUtility.get_value_pairs(self.result, "sftp-files")
+
+    def run(self):
+        self.csvpaths.logger.info("Checking for requests to send result files by SFTP")
+        self.results = self.csvpaths.results_manager.get_named_results(
+            self.metadata.named_results_name
+        )
+        for result in self.results:
+            self.result = result
+            self._collect_fields()
+            self._metadata_update()
+
+    def metadata_update(self, mdata: Metadata) -> None:
+        if mdata is None:
+            raise ValueError("Metadata cannot be None")
+        if not isinstance(mdata, ResultsMetadata):
+            if self.csvpaths:
+                self.csvpaths.logger.warning(
+                    "SftpSender only listens for results events. Other event types are ignored."
+                )
+            return
+        if mdata.status == ResultsRegistrar.COMPLETE:
+            self.metadata = mdata
+            self.start()
+
+    def _metadata_update(self) -> None:
+        if (
+            self._files is None or len(self._files) == 0
+        ) and self._send_original is not True:
+            # no files to send and not sending the original data means we're done
+            return
+        files = [
+            "data.csv",
+            "unmatched.csv",
+            "errors.json",
+            "vars.json",
+            "meta.json",
+            "printouts.txt",
+            "manifest.json",
+        ]
+        sep = Nos(self.metadata.run_home).sep
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        try:
+            client.connect(self._server, self._port, self._user, self._password)
+            sftp = client.open_sftp()
+            self.csvpaths.logger.info("Preparing to send %s files", len(self._files))
+            try:
+                sftp.stat(self._target_path)
+            except FileNotFoundError:
+                sftp.mkdir(self._target_path)
+            for pair in self._files:
+                file = pair[0]
+                to = pair[1]
+                if file not in files:
+                    raise ValueError("File name {file} is not in {files}")
+                if to is None:
+                    raise ValueError("File name {file} has no destination")
+                path = f"/Users/davidkershaw/dev/csvpath/{self.metadata.run_home}{sep}{self.result.identity_or_index}{sep}{file}"
+                remote_path = f"{self._target_path}/{to}"
+                self.csvpaths.logger.info("Putting %s to %s", path, remote_path)
+                sftp.put(path, remote_path)
+            #
+            # send the original file if we need to. this will always be the normative
+            # original, w/o regard to source-mode or by_line chaining or to rewind.
+            #
+            if self._original is True:
+                path = self.results[0].csvpath.scanner.filename
+                if path is None:
+                    raise ValueError("Filename of first result cannot be None")
+                remote_file = path[path.rfind(sep) + 1 :]
+                remote_path = f"{self._target_path}/{remote_file}"
+                sftp.put(path, remote_path)
+
+            sftp.close()
+        finally:
+            client.close()

csvpath-0.0.506/csvpath/managers/integrations/sftpplus/arrival_handler.py

@@ -0,0 +1,74 @@
+import subprocess
+import os
+from csvpath import CsvPaths
+
+
+#
+# this class is executed when a file arrives on a transfer set up
+# by TransferCreator to handle inbound named-files.
+#
+class SftpPlusArrivalHandler:
+    def __init__(self, path):
+        self._csvpaths = CsvPaths()
+        self._path = path
+        self._named_file_name = None
+        self._named_paths_name = None
+        self._run_method = None
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @property
+    def run_method(self) -> str:
+        return self.run_method
+
+    @run_method.setter
+    def run_method(self, n: str) -> None:
+        self.run_method = n
+
+    @property
+    def named_file_name(self) -> str:
+        return self._named_file_name
+
+    @named_file_name.setter
+    def named_file_name(self, n: str) -> None:
+        self._named_file_name = n
+
+    @property
+    def named_paths_name(self) -> str:
+        return self._named_paths_name
+
+    @named_paths_name.setter
+    def named_paths_name(self, n: str) -> None:
+        self._named_paths_name = n
+
+    def process_arrival(self) -> None:
+        #
+        # register the file
+        #
+        self._csvpaths.file_manager.add_named_file(
+            name=self.named_file_name, path=self.path
+        )
+        #
+        # do the run
+        #
+        m = self.run_method
+        if m is None or self.run_method == "collect_paths":
+            self._csvpaths.collect_paths(
+                filename=self.named_file_name, pathsname=self.named_paths_name
+            )
+        elif m == "fast_forward_paths":
+            self._csvpaths.fast_forward_paths(
+                filename=self.named_file_name, pathsname=self.named_paths_name
+            )
+        elif m == "collect_by_line":
+            self._csvpaths.collect_by_line(
+                filename=self.named_file_name, pathsname=self.named_paths_name
+            )
+        elif m == "fast_forward_by_line":
+            self._csvpaths.fast_forward_by_line(
+                filename=self.named_file_name, pathsname=self.named_paths_name
+            )
+        else:
+            self._csvpaths.config.error("Run method is incorrect: {m}")

csvpath-0.0.506/csvpath/managers/integrations/sftpplus/sftpplus_listener.py

@@ -0,0 +1,185 @@
+import os
+import json
+import threading
+import paramiko
+from tempfile import NamedTemporaryFile
+from csvpath.managers.metadata import Metadata
+from csvpath.managers.results.results_metadata import PathsMetadata
+from csvpath.managers.listener import Listener
+from csvpath.util.var_utility import VarUtility
+
+
+#
+# this class listens for paths events. when it gets one it generates
+# a file of instructions and sends them to an SFTPPlus mailbox account.
+# a transfer on the landing dir moves the instructions to a holding
+# location for future reference: `user`/csvpath_messages/handled
+#
+# before the move happens a script runs to process the instructions.
+# the instructions set up a transfer for the named-paths group's
+# expected file arrivals.
+#
+# that transfer executes a script that loads the files as named-files and
+# executes a run of the named-paths on the new named-file. it then moves
+# the arrived file to a holding location for process debugging reference.
+# the single-source authorative file is at this point in the named-files
+# inputs directory, whereever that is configured.
+#
+class SftpPlusListener(Listener, threading.Thread):
+    def __init__(self, *, config=None):
+        super().__init__(config)
+        self._server = None
+        self._port = None
+        self._user = None
+        self._password = None
+        self._target_path = "csvpath_messages"
+        self._delete_on_success = True
+        self._publish = False
+        self._expected_file_name = None
+        self._execute_before_script_name = None
+        self.csvpaths = None
+        self.result = None
+        self.metadata = None
+        self.results = None
+
+    def _collect_fields(self) -> None:
+        # directives stuff:
+        self._publish = VarUtility.get_bool(self.result, "sftpplus-publish")
+        self._expected_file_name = VarUtility.get_str(
+            self.result, "sftpplus-named-file-name"
+        )
+        self._method = VarUtility.get_str(self.result, "sftpplus-run-method")
+        # config.ini stuff:
+        self._user = self.csvpath.config.get(section="sftpplus", name="admin_user")
+        if self._user is None:
+            raise ValueError("SFTPPlus Admin username cannot be None")
+        if self._user.isupper():
+            self._user = os.getenv(self._user)
+        self._password = self.csvpath.config.get(
+            section="sftpplus", name="admin_password"
+        )
+        if self._password is None:
+            raise ValueError("SFTPPlus Admin password cannot be None")
+        if self._password.isupper():
+            self._password = os.getenv(self._password)
+        self._server = self.csvpath.config.get(section="sftpplus", name="server")
+        if self._server is None:
+            raise ValueError("SFTPPlus server cannot be None")
+        if self._server.isupper():
+            self._server = os.getenv(self._server)
+        self._port = self.csvpath.config.get(section="sftpplus", name="port")
+        if self._port is None:
+            raise ValueError("SFTPPlus port cannot be None")
+        if self._port.isupper():
+            self._port = os.getenv(self._port)
+        self._delete_on_success = self.csvpath.config.get(
+            section="sftpplus",
+            name="sftpplus-delete-on-success",
+            default=self._delete_on_success,
+        )
+
+    @property
+    def run_method(self) -> str:
+        if self._method is None or self._method not in [
+            "collect_paths",
+            "fast_forward_paths",
+            "collect_by_line",
+            "fast_forward_by_line",
+        ]:
+            self.csvpaths.logger.warning(
+                "No acceptable sftpplus-run-method found by SftpSender for {self.metadata.named_paths_name}: {self._method}. Defaulting to collect_paths."
+            )
+            self._method = "collect_paths"
+        return self._method
+
+    @property
+    def scripts_base(self) -> str:
+        return self.csvpaths.config.get(section="sftppath", name="scripts_base")
+
+    @property
+    def script_dir(self) -> str:
+        return self.csvpaths.config.get(section="sftppath", name="scripts_dir")
+
+    @property
+    def execute_before_script_name(self) -> str:
+        return self.csvpaths.config.get(
+            section="sftppath", name="execute_before_script_name"
+        )
+
+    def run(self):
+        self.csvpaths.logger.info("Checking for requests to send result files by SFTP")
+        self._metadata_update()
+
+    def metadata_update(self, mdata: Metadata) -> None:
+        if mdata is None:
+            raise ValueError("Metadata cannot be None")
+        if not isinstance(mdata, PathsMetadata):
+            if self.csvpaths:
+                self.csvpaths.logger.warning(
+                    "SftpplusListener only listens for paths events. Other event types are ignored."
+                )
+        self.metadata = mdata
+        self.start()
+
+    def _metadata_update(self) -> None:
+        self._collect_fields()
+        msg = self._create_instructions()
+        self._send_message(msg)
+
+    def _send_message(self, msg: dict) -> None:
+        #
+        # write instructions message into a temp file
+        #
+        with NamedTemporaryFile(mode="w+t", delete_on_close=False) as file:
+            json.dump(msg, file, indent=2)
+            file.close()
+            file.seek(0)
+
+            client = paramiko.SSHClient()
+            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            try:
+                client.connect(self._server, self._port, self._user, self._password)
+                sftp = client.open_sftp()
+                self.csvpaths.logger.info(
+                    "SFTPPlus listener prepping instruction to %s",
+                    f"{self._user}/{self._target_path}",
+                )
+                #
+                # create the remote dir, in the messages account, if needed.
+                #
+                try:
+                    sftp.stat(self._target_path)
+                except FileNotFoundError:
+                    sftp.mkdir(self._target_path)
+                #
+                # land the file at the UUID so that if anything weird we'll only ever
+                # interfere with ourselves.
+                #
+                remote_path = f"{self._target_path}/{self.metadata.uuid_string}.txt"
+                self.csvpaths.logger.info("Putting %s to %s", file, remote_path)
+                sftp.putfo(file, remote_path)
+                sftp.close()
+            finally:
+                client.close()
+
+    def _create_instructions(self) -> dict:
+        #
+        # SFTPPLUS TRANSFER SETUP STUFF
+        # we are making the file-receiving transfer, not the message-receiving
+        # transfer. this will be used by the message-receiving transfer to prep
+        # the landing site for new files to be run against this named-paths.
+        #
+        msg = {}
+        msg["name"] = self.metadata.named_paths_name
+        msg["method"] = self.metadata.named_paths_name
+        msg[
+            "execute_before"
+        ] = f"{self.scripts_base}/{self.scripts_dir}/{self.execute_before_script_name}"
+        msg["delete_source_on_success"] = f"{self._delete_on_success}"
+        msg["source_uuid"] = "DEFAULT-LOCAL-FILESYSTEM"
+        msg["source_path"] = f"{self._expected_file_name}"
+        msg["destination_uuid"] = "DEFAULT-LOCAL-FILESYSTEM"
+        msg["destination_path"] = f"{self._expected_file_name}/handled"
+        msg["description"] = f"{self.metadata.uuid_string}"
+        msg["named_file_name"] = f"{self._expected_file_name}"
+        msg["publish"] = f"{self._publish}"

csvpath-0.0.506/csvpath/managers/integrations/sftpplus/transfer_creator.py

@@ -0,0 +1,212 @@
+import subprocess
+import os
+import json
+from csvpath import CsvPaths
+from csvpath.util.config import Config
+
+
+#
+# this class listens for messages. when it gets one it generates
+# instructions for admin-shell.
+#
+# we also generate another script for the new transfer. that script
+# loads the files as named-files and executes a run of the named-paths
+# on the new named-file.
+#
+# it then moves the arrived file to a holding location for process
+# debugging reference. the single-source authorative file is at this
+# point in the named-files inputs directory, whereever that is
+# configured.
+#
+class SftpPlusTransferCreator:
+    CSVPATH_ADMIN_PASSWORD = "CSVPATH_ADMIN_PASSWORD"
+
+    def __init__(self):
+        self._csvpaths = CsvPaths()
+        self._path = None
+
+    @property
+    def message_path(self) -> str:
+        return self._path
+
+    @message_path.setter
+    def message_path(self, p: str) -> None:
+        self._path = p
+
+    @property
+    def admin_username(self) -> str:
+        n = os.getenv(SftpPlusTransferCreator.CSVPATH_ADMIN_PASSWORD)
+        if n is not None:
+            return n
+        return self.config["sftpplus"]["admin_username"]
+
+    @property
+    def admin_password(self) -> str:
+        pw = os.getenv(SftpPlusTransferCreator.CSVPATH_ADMIN_PASSWORD)
+        if pw is not None:
+            return pw
+        return self.config["sftpplus"]["admin_password"]
+
+    @property
+    def config(self) -> Config:
+        return self._csvpaths.config
+
+    def process_message(self, msg_path) -> None:
+        #
+        # loads method as a single string
+        #
+        msg = self._get_message()
+        #
+        # the named-path uuid is in the message's (and transfer's) description field
+        # iterate the existing transfers looking for a description matching the named-paths
+        # group's uuid
+        #
+        tuuid = self._find_existing_transfer(msg)
+        #
+        # if tuuid exists we update the existing transfer
+        # otherwise we create a new transfer.
+        #
+        if tuuid is None:
+            tuuid = self._create_new_transfer(msg=msg)
+        else:
+            self._update_existing_transfer(tuuid=tuuid, msg=msg)
+        #
+        # generate the script that will load the named-file and run the named-paths when
+        # a new file arrives at the transfer.
+        #
+        self._generate_and_place_scripts(msg)
+
+    #
+    # ===================
+    #
+    def _get_message(self) -> dict:
+        msg = None
+        with open(self.message_path, "r", encoding="utf-8") as file:
+            msg = json.load(file)
+        uuid = msg.get("uuid")
+        if uuid is None:
+            raise ValueError(
+                "uuid of named-paths group must be present in transfer setup message: {msg}"
+            )
+        #
+        # any other validations here
+        #
+        return msg
+
+    def _cmd(self, cmd: str) -> str:
+        c = """echo {self.admin_password} | ./bin/admin-shell.sh -k -u {self.admin_username} -p - {cmd} """
+        return c
+
+    def _find_existing_transfer(self, msg: dict) -> str:
+        #
+        # we use admin-shell's show transfer command to find our uuid match in
+        # the description field. if we find that we return the transfer's uuid.
+        # if the transfer exists we want to update it.
+        #
+        # create the command:
+        cmd = self._cmd("show transfer")
+        # run the command
+        out = self._run_cmd(cmd)
+        # parse the list
+        tuuid = None
+        ts = out.split("--------------------------------------------------")
+        for t in ts:
+            if t.find(msg["uuid"]) > -1:
+                i = t.find("uuid = ")
+                tuuid = t[i + 8 : t.find('"', start=i + 9)]
+        return tuuid
+
+    def _run_cmd(self, cmd: str) -> str:
+        parts = cmd.split(" ")
+        result = subprocess.run(parts, capture_output=True, text=True)
+        code = result.returncode
+        output = result.stdout
+        error = result.stderr
+        print(f"_run_command: code: {code}, error: {error}")
+        print(f"_run_command: output: {output}")
+        return output
+
+    def _create_transfer(self, name: str) -> str:
+        c = self._cmd(f"add transfer {name}")
+        o = self._run_cmd(c)
+        #
+        # output is like:
+        #   New transfers created with UUID: f6ec10a0-baff-449d-9ba2-f89748b10dd4
+        #
+        i = o.find("UUID: ")
+        tuuid = o[i + 1 :]
+        print(f"_create_transfer: output: {o}")
+        print(f"_create_transfer: tuuid: {tuuid}")
+        return tuuid
+
+    def _create_new_transfer(self, *, msg: dict) -> str:
+        # create the commands
+        tuuid = self._create_transfer(msg["named_file_name"])
+        cmds = [
+            self._cmd(
+                f"configure transfer {tuuid} execute_before = {msg['execute_before']}"
+            ),
+            self._cmd(
+                f"configure transfer {tuuid} delete_source_on_success = {msg['delete_source_on_success']}"
+            ),
+            self._cmd(f"configure transfer {tuuid} source_uuid = {msg['source_uuid']}"),
+            self._cmd(f"configure transfer {tuuid} source_path = {msg['source_path']}"),
+            self._cmd(
+                f"configure transfer {tuuid} destination_uuid = {msg['destination_uuid']}"
+            ),
+            self._cmd(
+                f"configure transfer {tuuid} destination_path = {msg['destination_path']}"
+            ),
+            self._cmd(f"configure transfer {tuuid} enabled = {msg['publish']}"),
+        ]
+        for cmd in cmds:
+            self._run_cmd(cmd)
+
+    def _update_existing_transfer(self, *, tuuid: str, msg: dict) -> None:
+        cmds = [
+            #
+            # we'll take execute_before to give us a relatively easy way to allow for
+            # the script changing.
+            #
+            self._cmd(
+                f"configure transfer {tuuid} execute_before = {msg['execute_before']}"
+            ),
+            self._cmd(
+                f"configure transfer {tuuid} delete_source_on_success = {msg['delete_source_on_success']}"
+            ),
+            self._cmd(f"configure transfer {tuuid} enabled = {msg['publish']}"),
+        ]
+        for cmd in cmds:
+            self._run_cmd(cmd)
+
+    def _generate_and_place_scripts(self, msg: dict) -> str:
+        path = msg["execute_before"]
+        #
+        # we may need a setting for using poetry vs. pip, etc.
+        #
+        s = """
+poetry run python transfer_creator_main.py "$1"
+        """
+        with open(path, "w", encoding="utf-8") as file:
+            file.write(s)
+        #
+        # do we need to +x the script?
+        #
+        #
+        # create the main.py that uses the handler to add the new named-file
+        # and run the named-paths group
+        #
+        s = """
+import sys
+from csvpath.managers.integrations.sftpplus.arrival_handler import SftpPlusArrivalHandler
+
+if __name__ == "__main__":
+    path = sys.argv[1]
+    h = SftpPlusArrivalHandler(path)
+    h.named_file_name = "{msg['named_file_name']}"
+    h.run_method = "{msg['method']}"
+    h.named_paths_name = "{msg['name']}"
+    h.process_arrival()
+"""
+        with open(path, "w", encoding="utf-8") as file:
+            file.write(s)

{csvpath-0.0.504 → csvpath-0.0.506}/csvpath/managers/paths/paths_manager.py

@@ -39,7 +39,7 @@ class PathsManager:
 
     def named_paths_home(self, name: NamedPathsName) -> str:
         home = os.path.join(self.named_paths_dir, name)
-        if not Nos(home).exists():
+        if not Nos(home).dir_exists():
             Nos(home).makedirs()
         return home
 
@@ -198,7 +198,8 @@ class PathsManager:
         j = ""
         with DataFileReader(jsonpath) as file:
             j = file.read()
-        with DataFileWriter(path=os.path.join(home, "definition.json")) as writer:
+        p = os.path.join(home, "definition.json")
+        with DataFileWriter(path=p) as writer:
             writer.write(j)
 
     @property