Python.LORIS.candidates

Complexity

Total Complexity

42

Size/Duplication

Total Lines	280
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	LORIS_candidates.parse_PSCID()	0	27	5
A	LORIS_candidates.deleteCandidateCNBP()	0	26	3
A	LORIS_candidates.check_instutitionID_compliance()	0	10	2
A	LORIS_candidates.check_PSCID_compliance()	0	32	5
A	LORIS_candidates.check_DCCID()	0	17	5
A	LORIS_candidates.createCandidateCNBP()	0	36	4
A	LORIS_candidates.check_subjectID_compliance()	0	9	4
B	LORIS_candidates.checkDCCIDExist()	0	35	5
A	LORIS_candidates.check_projectID_compliance()	0	15	2
B	LORIS_candidates.checkPSCIDExist()	0	45	7

from subprocess import check_call

This module should have a docstring.

import sys
import os
import re
import json
import logging
from dotenv import load_dotenv
from LORIS.query import LORIS_query

Unable to import 'LORIS.query'

from LORIS.helper import LORIS_helper

Unable to import 'LORIS.helper'

from LocalDB.schema import CNBP_blueprint

The name schema does not seem to exist in module LocalDB.

Unable to import 'LocalDB.schema'

logging.basicConfig(stream=sys.stdout, level=logging.INFO)
#logger = logging.getLogger('LORISQuery')

class LORIS_candidates:

The name LORIS_candidates does not conform to the class naming conventions ([A-Z_][a-zA-Z0-9]+$).

This class should have a docstring.

The variable __class__ seems to be unused.

    @staticmethod
    def parse_PSCID(PSCID):

The name parse_PSCID does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name PSCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        """
        Return three parts of the PSCID: institution, project, subject
        :param PSCID:
        :return:
        """
        success = load_dotenv()
        if not success:
            raise ImportError("Credential .env NOT FOUND! Please ensure .env is set with all the necessary credentials!")

This line is too long as per the coding-style (121/100).

        # Loading regular expression
        re_institution = CNBP_blueprint.PSCID_schema_institution
        re_project = CNBP_blueprint.PSCID_schema_project
        re_subject = CNBP_blueprint.PSCID_schema_subject

        # Use expression to extract from the inputted PSCID
        input_institution = re.search(re_institution, PSCID).group(0)
        input_project = re.search(re_project, PSCID).group(0)
        input_subject = re.search(re_subject, PSCID).group(0)

        if input_subject is None or input_project is None or input_institution is None:
            success = False
        else:
            success = True

        return success, input_institution, input_project, input_subject

    @staticmethod
    def check_instutitionID_compliance(input_institutionID):

The name check_instutitionID_compliance does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name input_institutionID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

This method should have a docstring.

        # Parse from the .env standardization
        InsitituionID = os.getenv("institutionID")

The name InsitituionID does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        # Check if institution ID matches
        if not (input_institutionID == InsitituionID):

There is an unnecessary parenthesis after not.

Unnecessary "else" after "return"

            return False
        else:
            return True

    @staticmethod
    def check_projectID_compliance(input_projectID):

The name check_projectID_compliance does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name input_projectID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

This method should have a docstring.

        # Load ProjectIDs from the environment.
        success = load_dotenv()
        if not success:
            raise ImportError("Credential .env NOT FOUND! Please ensure .env is set with all the necessary credentials!")

This line is too long as per the coding-style (121/100).

        projectID_dictionary_json: str = os.getenv("projectID_dictionary")

The name projectID_dictionary_json does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        projectID_list = json.loads(projectID_dictionary_json)

The name projectID_list does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        # check if project ID is in the projectID list.
        isRecognized = input_projectID in projectID_list

The name isRecognized does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        return isRecognized

    @staticmethod
    def check_subjectID_compliance(input_subjectID):

The name check_subjectID_compliance does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name input_subjectID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

This method should have a docstring.

        if not input_subjectID.isdigit():
            return False

        if int(input_subjectID) < 9999 or int(input_subjectID) > 0:

The if statement can be replaced with 'return bool(test)'

Unnecessary "else" after "return"

            return True
        else:
            return False

    @staticmethod
    def check_PSCID_compliance(PSCID):

The name check_PSCID_compliance does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name PSCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        """
        Checks PSCID inputed for 1) InstitionID format, 2) ProjectID format, 3) SubjectID format.
        :param PSCID:
        :return:
        """
        logger = logging.getLogger(__name__)

        # Parse from input PSCID
        success, input_institution, input_project, input_subject = LORIS_candidates.parse_PSCID(PSCID)

This line is too long as per the coding-style (102/100).

        # Ensure parsing success
        if not success:
            return False

        # Check institution ID to ensure that
        if not LORIS_candidates.check_instutitionID_compliance(input_institution):
            logger.info("Institution not compliant")
            return False

        # Check if projectID already exist
        if not LORIS_candidates.check_projectID_compliance(input_project):
            logger.info("ProjectID not recognized")
            return False

        # Check last four digits: make sure the last four characters are digits.
        if not LORIS_candidates.check_subjectID_compliance(str(input_subject)):
            logger.info("SubjectID not standardized")
            return False

        return True

    @staticmethod
    def check_DCCID(DCCID):

The name check_DCCID does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name DCCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        """
        Check if DCCID id conform.
        :param DCCID:
        :return:
        """
        if not len(str(DCCID)) == 6:

Unnecessary "else" after "return"

Consider changing "not len(str(DCCID)) == 6" to "len(str(DCCID)) != 6"

            return False
        elif not str(DCCID).isnumeric():
            return False
        elif DCCID > 999999:
            return False
        elif DCCID < 0:
            return False
        else:
            return True

    @staticmethod
    def deleteCandidateCNBP(token, DCCID, PSCID):

The name deleteCandidateCNBP does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name DCCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name PSCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

This method should have a docstring.

The argument token seems to be unused.

        logger = logging.getLogger('UT_LORIS_delete_subject')

        # Load the hard coded variables.
        success = load_dotenv()
        if not success:
            raise ImportError("Credential .env NOT FOUND! Please ensure .env is set with all the necessary credentials!")

This line is too long as per the coding-style (121/100).

        ProxyIP = os.getenv("ProxyIP")

The name ProxyIP does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        ProxyUsername = os.getenv("ProxyUsername")

The name ProxyUsername does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        ProxyPassword = os.getenv("ProxyPassword")

The name ProxyPassword does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        LORISHostPassword = os.getenv("LORISHostPassword")

The name LORISHostPassword does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        LORISHostUsername = os.getenv("LORISHostUsername")

The name LORISHostUsername does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        LORISHostIP = os.getenv("LORISHostIP")

The name LORISHostIP does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        DeletionScript = os.getenv("DeletionScript")

The name DeletionScript does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        # Export some variables for subsequent deletion clean script against production database (yes... because we could not automate LORIS development...):

This line is too long as per the coding-style (157/100).

        command_string = ["sshpass", "-p", ProxyPassword, "ssh", ProxyUsername + "@" + ProxyIP, "-t", "sshpass", "-p",

This line is too long as per the coding-style (118/100).

                          LORISHostPassword, "ssh", "-L", "3001:localhost:22",
                          LORISHostUsername + "@" + LORISHostIP, "php", DeletionScript, "delete_candidate", str(DCCID),

This line is too long as per the coding-style (119/100).

                          PSCID, "confirm"]

        logger.info(command_string)
        if 'TRAVIS' in os.environ:
            logger.info("Running LORIS delete candidate that was created for: " + PSCID)
            check_call(command_string)

    @staticmethod
    def createCandidateCNBP(token, proposed_PSCID):

The name createCandidateCNBP does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name proposed_PSCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        """
        Create a candidate using the given PSCID
        :param token
        :param proposed_PSCID:
        :return: DCCID
        """
        logger = logging.getLogger('LORIS_CreateCNBPCandidates')
        logger.info("Creating CNBP Candidates: " + proposed_PSCID)

        PSCID_exist = LORIS_candidates.checkPSCIDExist(token, proposed_PSCID)

The name PSCID_exist does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        if PSCID_exist:
            logger.info("PSCID already exist. Quitting.")
            return False

        Candidate = {}

The name Candidate does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        Candidate['Project'] = 'loris'
        Candidate['PSCID'] = proposed_PSCID
        Candidate['DoB'] = '2018-05-04'
        Candidate['Gender'] = 'Female'

        data = {"Candidate":Candidate}

        data_json = json.dumps(data)

        response_code, response = LORIS_query.postCNBP(token, "candidates/", data_json)
        if not LORIS_helper.is_response_success(response_code, 201):

Unnecessary "else" after "return"

            return False, None
        elif response is not None:  # only try to decode if response is not empty!
            response_json = response.json()
            meta = response_json.get('Meta')
            CandID = meta.get('CandID')

The name CandID does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            return True, CandID
        else:
            return False, None

    @staticmethod
    def checkPSCIDExist(token, proposed_PSCID):

The name checkPSCIDExist does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name proposed_PSCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        """
        Check if Site/Study already contain the PSCID
        :param token:
        :param proposed_PSCID:
        :return: bool for connection, bool on if such PSCID (INSTITUTIONID + PROJECTID + SUBJECTID) exist already.

This line is too long as per the coding-style (114/100).

        """
        logger = logging.getLogger('LORIS_checkPSCIDExist')
        logger.info("Checking if PSCID exist: "+proposed_PSCID)
        success = load_dotenv()
        if not success:
            raise ImportError("Credential .env NOT FOUND! Please ensure .env is set with all the necessary credentials!")

This line is too long as per the coding-style (121/100).

        institution_check = os.getenv("institutionID")


        #Get list of projects
        response_success, loris_project = LORIS_query.getCNBP(token, r"projects/loris")
        if not response_success:
            return response_success, None

        #Get list of candidates (Candidates in v0.0.1)
        candidates = loris_project.get("Candidates")
        logger.info(candidates)

        for DCCID in candidates: #these candidates should really be only from the same ID regions.

The name DCCID does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            response_success, candidate_json = LORIS_query.getCNBP(token, r"candidates/"+DCCID)
            if not response_success:
                return response_success, False
            # Each site following the naming convention should have SITE prefix and PI prefix and PROJECT prefix to avoid collision

This line is too long as per the coding-style (131/100).

            # A site check here.
            candidate_meta = candidate_json.get("Meta")
            candidate_pscID = candidate_meta.get("PSCID")

The name candidate_pscID does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            # Not gonna check is institution ID doesn't even match.
            if candidate_pscID[0:3] != institution_check:
                continue

            elif candidate_pscID == proposed_PSCID:
                return response_success, True

                #latest_timepoint = findLatestTimePoint(DCCID)

        return True, False

    @staticmethod
    def checkDCCIDExist(token, proposed_DCCID):

The name checkDCCIDExist does not conform to the method naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name proposed_DCCID does not conform to the argument naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

        """
        Check if Site/Study already contain the PSCID
        :param token:
        :param proposed_DCCID:
        :return:
        """
        logger = logging.getLogger('LORIS_checkDCCIDExist')
        logger.info("Checking if DCCID exist: "+str(proposed_DCCID))
        success = load_dotenv()
        if not success:
            raise ImportError("Credential .env NOT FOUND! Please ensure .env is set with all the necessary credentials!")

This line is too long as per the coding-style (121/100).

        institution_check = os.getenv("institutionID")

The variable institution_check seems to be unused.

        assert (LORIS_candidates.check_DCCID(proposed_DCCID))

There is an unnecessary parenthesis after assert.

        #Get list of projects
        response, loris_project = LORIS_query.getCNBP(token, r"projects/loris")
        response_success = LORIS_helper.is_response_success(response, 200)

        if not response_success:
            logger.info("FAILED log response: " + str(response))
            return response_success, None

        #Get list of candidates (Candidates in v0.0.1)
        candidates = loris_project.get("Candidates")
        logger.info(candidates)

        for DCCID in candidates:

The name DCCID does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

            if str(proposed_DCCID) == DCCID:
                return response_success, True
            else:
                continue
        return response_success, False

if __name__ == "__main__":
    print(LORIS_candidates.check_projectID_compliance("GL01"))

Final newline missing