Apply black formatting

Author: smlindauer

src/sasctl/pzmm/gitIntegration.py

@@ -12,8 +12,9 @@
 from .._services.model_repository import ModelRepository as mr
 from ..core import RestObj
 
+
 def getZippedModel(model, gPath, project=None):
-    '''Retrieve a zipped file containing all of the model contents or a specified 
+    """Retrieve a zipped file containing all of the model contents or a specified
     model. The project argument is only needed if the model argument is not a valid
     UUID or RestObj.
 
@@ -27,9 +28,9 @@ def getZippedModel(model, gPath, project=None):
     project : string or RestObj, optional
         Project identifier, which is required when only the model name is supplied. Default
         is None.
-    '''
-    params = {'format': 'zip'}
-    modelZip = mr.get('models/%s' % (model), params=params, format_='content')
+    """
+    params = {"format": "zip"}
+    modelZip = mr.get("models/%s" % (model), params=params, format_="content")
     modelName = mr.get_model(model).name
     # Check if the provided project variable is a REST object
     if isinstance(project, RestObj):
@@ -38,25 +39,32 @@ def getZippedModel(model, gPath, project=None):
         projectName = mr.get_project(project).name
     # Check to see if project folder exists
     if (Path(gPath) / projectName).exists():
-        #Check to see if model folder exists
+        # Check to see if model folder exists
         if (Path(gPath) / projectName / modelName).exists():
-            with open(Path(gPath) / projectName / modelName / (modelName + '.zip'), 'wb') as zFile:
+            with open(
+                Path(gPath) / projectName / modelName / (modelName + ".zip"), "wb"
+            ) as zFile:
                 zFile.write(modelZip)
         else:
             newDir = Path(gPath) / projectName / modelName
             newDir.mkdir(parents=True, exist_ok=True)
-            with open(Path(gPath) / projectName / modelName / (modelName + '.zip'), 'wb') as zFile:
+            with open(
+                Path(gPath) / projectName / modelName / (modelName + ".zip"), "wb"
+            ) as zFile:
                 zFile.write(modelZip)
     else:
         newDir = Path(gPath) / projectName
         newDir.mkdir(parents=True, exist_ok=True)
         newDir = Path(gPath) / projectName / modelName
         newDir.mkdir(parents=True, exist_ok=True)
-        with open(Path(gPath) / (projectName + '/' + modelName + '.zip'), 'wb') as zFile:
+        with open(
+            Path(gPath) / (projectName + "/" + modelName + ".zip"), "wb"
+        ) as zFile:
             zFile.write(modelZip)
 
     return modelName, projectName
 
+
 def project_exists(response, project):
     """Checks if project exists on SAS Viya. If the project does not exist, then a new
     project is created or an error is raised.
@@ -93,7 +101,8 @@ def project_exists(response, project):
             return response
     else:
         return response
-    
+
+
 def model_exists(project, name, force):
     """Checks if model already exists and either raises an error or deletes the redundant model.
 
@@ -138,6 +147,8 @@ def model_exists(project, name, force):
                             project.name
                         )
                     )
+
+
 class GitIntegrate:
     @classmethod
     def pullViyaModel(
@@ -146,14 +157,14 @@ def pullViyaModel(
         gPath,
         project=None,
     ):
-        '''Send an API request in order to pull a model from a project in 
+        """Send an API request in order to pull a model from a project in
         SAS Model Manager in a zipped format. The contents of the zip file
         include all files found in SAS Model Manager's model UI, except that
         read-only json files are updated to match the current state of the model.
-        
+
         After pulling down the zipped model, unpack the file in the model folder.
         Overwrites files with the same name.
-        
+
         If supplying a model name instead of model UUID, a project name or uuid must
         be supplied as well. Models in the model repository are allowed duplicate
         names, therefore we need a method of parsing the returned models.
@@ -166,7 +177,7 @@ def pullViyaModel(
             Base directory of the git repository.
         project : string or RestObj, optional
             A string or JSON response representing the project the model exists in, default is None.
-        '''
+        """
         # Try to pull down the model assuming a UUID or RestObj is provided
         try:
             if isinstance(model, RestObj):
@@ -190,24 +201,30 @@ def pullViyaModel(
                 try:
                     if model["name"] == model:
                         modelId = model.id
-                        modelName, projectName = getZippedModel(modelId, gPath, projectName)
+                        modelName, projectName = getZippedModel(
+                            modelId, gPath, projectName
+                        )
                 except TypeError:
                     if projectModels["name"] == model:
                         modelId = projectModels.id
-                        modelName, projectName = getZippedModel(modelId, gPath, projectName)
-                        
+                        modelName, projectName = getZippedModel(
+                            modelId, gPath, projectName
+                        )
+
         # Unpack the pulled down zip model and overwrite any duplicate files
-        mPath = Path(gPath) / '{projectName}/{modelName}'.format(projectName=projectName, modelName=modelName)
-        with zipfile.ZipFile(str(mPath / (modelName + '.zip')), mode='r') as zFile:
+        mPath = Path(gPath) / "{projectName}/{modelName}".format(
+            projectName=projectName, modelName=modelName
+        )
+        with zipfile.ZipFile(str(mPath / (modelName + ".zip")), mode="r") as zFile:
             zFile.extractall(str(mPath))
-        
+
         # Delete the zip model objects in the directory to minimize confusion when uploading back to SAS Model Manager
-        for zipFile in mPath.glob('*.zip'):
+        for zipFile in mPath.glob("*.zip"):
             zipFile.unlink()
-        
+
     @classmethod
     def pushGitModel(cls, gPath, modelName=None, projectName=None):
-        '''Push a single model in the git repository up to SAS Model Manager. This function
+        """Push a single model in the git repository up to SAS Model Manager. This function
         creates an archive of all files in the directory and imports the zipped model.
 
         Parameters
@@ -218,29 +235,31 @@ def pushGitModel(cls, gPath, modelName=None, projectName=None):
             Name of model to be imported, by default None
         projectName : string, optional
             Name of project the model is imported from, by default None
-        '''
+        """
         if modelName is None and projectName is None:
             modelDir = gPath
             modelName = modelDir.name
             projectName = modelDir.parent.name
         else:
-            modelDir = Path(gPath) / (projectName + '/' + modelName)
-        for zipFile in modelDir.glob('*.zip'):
-                zipFile.unlink()
+            modelDir = Path(gPath) / (projectName + "/" + modelName)
+        for zipFile in modelDir.glob("*.zip"):
+            zipFile.unlink()
         fileNames = []
-        fileNames.extend(sorted(Path(modelDir).glob('*')))
-        with zipfile.ZipFile(str(modelDir / (modelDir.name + '.zip')), mode='w') as zFile:
+        fileNames.extend(sorted(Path(modelDir).glob("*")))
+        with zipfile.ZipFile(
+            str(modelDir / (modelDir.name + ".zip")), mode="w"
+        ) as zFile:
             for file in fileNames:
                 zFile.write(str(file), arcname=file.name)
-        with open(modelDir / (modelDir.name + '.zip'), 'rb') as zFile:
+        with open(modelDir / (modelDir.name + ".zip"), "rb") as zFile:
             zipIOFile = io.BytesIO(zFile.read())
             # Check if model with same name already exists in project. Delete if it exists.
             model_exists(projectName, modelName, True)
             mr.import_model_from_zip(modelName, projectName, zipIOFile)
-        
+
     @classmethod
-    def gitRepoPush(cls, gPath, commitMessage, branch='origin'):
-        '''Create a new commit with new files, then push changes from the local repository to a remote 
+    def gitRepoPush(cls, gPath, commitMessage, branch="origin"):
+        """Create a new commit with new files, then push changes from the local repository to a remote
         branch. The default remote branch is origin.
 
         Parameters
@@ -251,32 +270,32 @@ def gitRepoPush(cls, gPath, commitMessage, branch='origin'):
             Commit message for the new commit
         branch : str, optional
             Branch name for the remote repository, by default 'origin'
-        '''
+        """
         repo = Repo(gPath)
         repo.git.add(all=True)
         repo.index.commit(commitMessage)
         pushBranch = repo.remote(name=branch)
         pushBranch.push()
-        
+
     @classmethod
-    def gitRepoPull(cls, gPath, branch='origin'):
-        '''Pull down any changes from a remote branch of the git repository. The default branch is
-        origin. 
+    def gitRepoPull(cls, gPath, branch="origin"):
+        """Pull down any changes from a remote branch of the git repository. The default branch is
+        origin.
 
         Parameters
         ----------
         gPath : string or Path
             Base directory of the git repository.
         branch : string
             Branch name for the remote repository, by default 'origin'
-        '''
+        """
         repo = Repo(gPath)
         pullBranch = repo.remote(name=branch)
         pullBranch.pull()
-        
+
     @classmethod
     def pullGitProject(cls, gPath, project=None):
-        '''Using a user provided project name, search for the project in the specified git repository,
+        """Using a user provided project name, search for the project in the specified git repository,
         check if the project already exists on SAS Model Manager (create a new project if it does not),
         then upload each model found in the git project to SAS Model Manager
 
@@ -286,33 +305,40 @@ def pullGitProject(cls, gPath, project=None):
             Base directory of the git repository or the project directory.
         project : string or RestObj
             Project name, UUID, or JSON response from SAS Model Manager.
-        '''
+        """
         # Check to see if provided project argument is a valid project on SAS Model Manager
         projectResponse = mr.get_project(project)
         project = project_exists(projectResponse, project)
         projectName = project.name
-            
+
         # Check if project exists in git path and produce an error if it does not
         pPath = Path(gPath) / projectName
         if pPath.exists():
-            models = [x for x in pPath.glob('*') if x.is_dir()]
+            models = [x for x in pPath.glob("*") if x.is_dir()]
             if len(models) == 0:
-                print('No models were found in project {}.'.format(projectName))
-            print('{numModels} models were found in project {projectName}.'.format(numModels=len(models), projectName=projectName))
+                print("No models were found in project {}.".format(projectName))
+            print(
+                "{numModels} models were found in project {projectName}.".format(
+                    numModels=len(models), projectName=projectName
+                )
+            )
         else:
-            raise FileNotFoundError('No directory with the name {} was found in the specified git path.'.format(project))
-        
+            raise FileNotFoundError(
+                "No directory with the name {} was found in the specified git path.".format(
+                    project
+                )
+            )
+
         # Loop through paths of models and upload each to SAS Model Manager
         for model in models:
             # Remove any extra zip objects in the directory
-            for zipFile in model.glob('*.zip'):
+            for zipFile in model.glob("*.zip"):
                 zipFile.unlink()
             cls.pushGitModel(model)
-            
-        
+
     @classmethod
     def pullMMProject(cls, gPath, project):
-        '''Following the user provided project argument, pull down all models from the
+        """Following the user provided project argument, pull down all models from the
         corresponding SAS Model Manager project into the mapped git directories.
 
         Parameters
@@ -321,32 +347,34 @@ def pullMMProject(cls, gPath, project):
             Base directory of the git repository.
         project : string or RestObj
             The name or id of the model project, or a RestObj representation of the project.
-        '''
+        """
         # Check to see if provided project argument is a valid project on SAS Model Manager
         projectResponse = mr.get_project(project)
         project = project_exists(projectResponse, project)
         projectName = project.name
-        
+
         # Check if project exists in git path and create it if it does not
         pPath = Path(gPath) / projectName
         if not pPath.exists():
             Path(pPath).mkdir(parents=True, exist_ok=True)
-            
+
         # Return a list of model names from SAS Model Manager project
-        modelResponse = mr.get('projects/{}/models'.format(project.id))
+        modelResponse = mr.get("projects/{}/models".format(project.id))
         if modelResponse == []:
-            raise FileNotFoundError('No models were found in the specified project. A new project folder ' + 
-                                    'has been created if it did not already exist within the git repository.')        
+            raise FileNotFoundError(
+                "No models were found in the specified project. A new project folder "
+                + "has been created if it did not already exist within the git repository."
+            )
         modelNames = []
         modelId = []
         for model in modelResponse:
             modelNames.append(model.name)
             modelId.append(model.id)
-        
+
         # For each model, search for an appropriate model directory in the project directory and pull down the model
         for name, id in zip(modelNames, modelId):
             mPath = pPath / name
             # If the model directory does not exist, create one in the project directory
             if not mPath.exists():
                 Path(mPath).mkdir(parents=True, exist_ok=True)
-            cls.pullViyaModel(id, mPath.parents[1])
+            cls.pullViyaModel(id, mPath.parents[1])

src/sasctl/pzmm/importModel.py

@@ -113,7 +113,7 @@ def pzmmImportModel(
         isH2OModel=False,
         force=False,
         binaryString=None,
-        missingValues=False
+        missingValues=False,
     ):
         """Import model to SAS Model Manager using pzmm submodule.
 
@@ -240,7 +240,7 @@ def getFiles(extensions):
                     isH2OModel=isH2OModel,
                     isBinaryModel=binaryModel,
                     binaryString=binaryString,
-                    missingValues=missingValues
+                    missingValues=missingValues,
                 )
                 print(
                     "Model score code was written successfully to {}.".format(
@@ -304,7 +304,7 @@ def getFiles(extensions):
                     isH2OModel=isH2OModel,
                     isBinaryModel=binaryModel,
                     binaryString=binaryString,
-                    missingValues=missingValues
+                    missingValues=missingValues,
                 )
                 print(
                     "Model score code was written successfully to {} and uploaded to SAS Model Manager".format(