コード例 #1
0
def myLocalLogTestFunc():
    """ example of logging from a function
    """

    logger = Logging.getLogger()
    logger.info("Test of Message")

    logger2 = Logging.getLogger("TestLogger")
    logger2.info("Test2 of Message")

    logger3 = Logging.getLogger(__name__)
    logger3.info("Test3 of Message")
コード例 #2
0
ファイル: sextractor.py プロジェクト: rfahed/extProcess
def mainMethod(args):
    """
    @brief The "main" method.
    @details
        This method is the entry point to the program. In this sense, it is 
        similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('sextractor')

    logger.info('#')
    logger.info('# Entering sextractor mainMethod()')
    logger.info('#')
    
    if args.zeropoint == "PER_S":
        zeropoints = image.get_zeropoints(args.image,apply_exptime=True,zerokey=args.zerokey)
    elif args.zeropoint == "INTEGRATED":
        zeropoints = image.get_zeropoints(args.image,apply_exptime=False,zerokey=args.zerokey)
    
    if args.outputcat == None :
        args.outputcat=utils.rm_extension(args.image)+".cat"
    
    image.sex(args.image,outputcat=args.outputcat)
    
    catalog.apply_zeropoints(args.outputcat,zeropoints)
    
    # !! Getting the option from the example option in defineSpecificProgramOption 
    # !! e.g string_option = args.string_value

    
    
    logger.info('#')
    logger.info('# Exiting sextractor mainMethod()')
    logger.info('#')
コード例 #3
0
class ClassExample(object):
    """
    This is an example of the most basic Python class
    """
    logger = log.getLogger('ClassExample')

    def __init__(self, my_list):
        """
        Constructor
        """
        self._m_i = 5
        self._m_list = my_list

    def sumListValues(self):
        """
        Method summing the elements of the list
        """
        my_sum = 0
        for element in self._m_list:
            my_sum += element
        return my_sum

    @staticmethod
    def product(first, second):
        """
        This is an example static method

        :param first: The first number
        :param second: The second number

        :return: The product of the two numbers
        """
        return first * second
コード例 #4
0
def mainMethod(args):
    """
    @brief The "main" method.
    @details This method is the entry point to the program. In this sense, it is similar to a main
    (and it is why it is called mainMethod()). The code below contains the calls to the
    different classes created for the first developer's workshop

        See the ElementsProgram documentation for more details.
    """
    logger = log.getLogger('SomeOtherScript')
    logger.info('Entering SomeOtherScript mainMethod()')

    #
    #  Log some of the arguments
    #
    int_from_configuration = args.int_option
    if not int_from_configuration:
        int_from_configuration = 9
    logger.info('Example int : %d', int_from_configuration)

    ThatFunction()

    logger.info('Exiting SomeOtherScript mainMethod()')

    return 0
コード例 #5
0
ファイル: makeregionfile.py プロジェクト: rfahed/extProcess
def mainMethod(args):
    """
    @brief The "main" method.
    @details
        This method is the entry point to the program. In this sense, it is 
        similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('makeregionfile')

    logger.info('#')
    logger.info('# Entering makeregionfile mainMethod()')
    logger.info('#')

    # !! Getting the option from the example option in defineSpecificProgramOption 
    # !! e.g string_option = args.string_value

    #
    cat = catalog.read(args.catalog,format=args.format)
    regionfile = utils.rm_extension(args.catalog)+'.reg'
    if args.subtag is None :
        args.subtag = ''
        
    catalog.toRegionFile(cat, regionfile, symbol = args.symbol, subtag=args.subtag, wcs=args.wcs)
    #

    logger.info('#')
    logger.info('# Exiting makeregionfile mainMethod()')
    logger.info('#')
コード例 #6
0
ファイル: Temporary.py プロジェクト: ayllon/Elements
 def _destruct(self):
     """Internal function to remove the resource"""
     if self._name:
         if self._keep_var in os.environ:
             log = Logging.getLogger(None)
             log.info("%s set: I do not remove the '%s' temporary path",
                      self._keep_var, self._name)
         else:
             self._delResource()
             self._name = None
コード例 #7
0
def mainMethod(args):
    """
    Main
    """

    exit_code = Exit.Code["OK"]

    logger = log.getLogger('CreateElementsProject')

    logger.info('#')
    logger.info(
        '#  Logging from the mainMethod() of the CreateElementsProject script')
    logger.info('#')

    proj_name = args.project_name
    proj_version = args.project_version
    dependant_projects = args.dependency
    destination_path = Project.setPath()
    dependency = args.dependency
    no_version_directory = args.no_version_directory
    standalone = args.standalone
    force_erase = args.erase
    answer_yes = args.yes

    logger.info('# Installation directory : %s', destination_path)

    try:
        # Set the project directory
        project_dir = Project.getProjectDirectory(no_version_directory,
                                                  destination_path, proj_name,
                                                  proj_version)
        Project.makeChecks(proj_name, proj_version, dependency,
                           dependant_projects)

        Project.checkProjectExist(project_dir, no_version_directory,
                                  force_erase, answer_yes)

        # Create the project
        Project.createProject(project_dir, proj_name, proj_version,
                              dependant_projects, standalone)

        # Print all files created
        ProjectCommonRoutines.printCreationList()

        logger.info('# <%s> project successfully created.', project_dir)

    except Exception as msg:
        if str(msg):
            logger.error(msg)
        logger.error('# Script aborted.')
        exit_code = Exit.Code["NOT_OK"]
    else:
        logger.info('# Script over.')

    return exit_code
コード例 #8
0
ファイル: Temporary.py プロジェクト: ayllon/Elements
 def __delitem__(self, key):
     """
     Unset an environment variable.
     Needed to provide the same interface as os.environ.
     """
     key = self._fix_key(key)
     if key not in self.env:
         raise KeyError(key)
     self.old_values[key] = self.env[key]
     del self.env[key]
     log = Logging.getLogger(None)
     log.info("removed %s from environment", key)
コード例 #9
0
def mainMethod(args): #pylint: disable=unused-argument
    """ The "main" method.
    This method is the entry point to the program. In this sense, it is similar to a main
    (and it is why it is called mainMethod()). The code below contains the calls to the
    different classes created for the first developer's workshop. See the ElementsProgram
    documentation for more details.
    """
    logger = Logging.getLogger('TestProgramExample')
    logger.info('Entering TestProgramExample mainMethod()')

    logger.info('Exiting TestProgramExample mainMethod()')

    return Exit.Code["OK"]
コード例 #10
0
 def __init__(self, app_module,
              parent_project_version=None, parent_project_name=None,
              parent_project_vcs_version=None,
              elements_module_name=None, elements_module_version=None,
              search_dirs=None, original_path="",
              elements_loglevel=logging.DEBUG):
     self._app_module = importlib.import_module(app_module)
     self._logger = log.getLogger('ElementsProgram')
     self._elements_loglevel = elements_loglevel
     self._parent_project_version = parent_project_version
     self._parent_project_name = parent_project_name
     self._parent_project_vcs_version = parent_project_vcs_version
     self._elements_module_name = elements_module_name
     self._elements_module_version = elements_module_version
     self._search_dirs = search_dirs
     self._program_path = os.path.dirname(original_path)
     self._program_name = os.path.basename(original_path)
     self._env = Environment()
コード例 #11
0
def mainMethod(args):
    """ The "main" method.
    This method is the entry point to the program. In this sense, it is similar to a main
    (and it is why it is called mainMethod()). The code below contains the calls to the
    different classes created for the first developer's workshop

        See the ElementsProgram documentation for more details.
    """
    logger = Logging.getLogger('ProgramExample')
    logger.info('Entering ProgramExample mainMethod()')

    #
    #  function with log messages
    #
    myLocalLogTestFunc()

    #
    #  Log some of the arguments
    #
    string_from_configuration = args.string_option
    logger.info('Example string : %s', string_from_configuration)
    second_element = args.int_list_option[1]
    logger.info('Second elements from the list : %s', str(second_element))

    logger.info("the int_option value %d", args.int_option)
    logger.info("the threshold value %.1f", args.threshold)

    #
    #  Calling a static method
    #
    result = ClassExample.product(3, 4)
    logger.info('Static method result : %s', str(result))

    #
    #  Calling the constructor and a method member
    #
    example_object = ClassExample(args.int_list_option)
    logger.info('Sum of the list elements : %s',
                str(example_object.sumListValues()))

    logger.info('Exiting ProgramExample mainMethod()')

    return Exit.Code["OK"]
コード例 #12
0
ファイル: mergecatalogs.py プロジェクト: rfahed/extProcess
def mainMethod(args):
    """
    @brief The "main" method.
    @details
        This method is the entry point to the program. In this sense, it is 
        similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('mergecatalogs')

    logger.info('#')
    logger.info('# Entering mergecatalogs mainMethod()')
    logger.info('#')

    # !! Getting the option from the example option in defineSpecificProgramOption 
    # !! e.g string_option = args.string_value

    catalogs = []
    for i,cat in enumerate(args.catalogs) :
	if len(args.format) > 1:
		ft = args.format[i] 
        catalogs.append(catalog.read(cat,format=ft))
    
    if len(args.catalogs) == 2:
        mcats=[utils.rm_extension(c)+'_matchtag.cat' for c in args.catalogs]
    mergedcat = catalog.mergecats(catalogs,delta=args.tol,filters=args.filters,mcats=mcats)

    #with open(args.outputcat, 'w') as f :
    #    fits.write(mergedcat, f)
    catalog.writefits(mergedcat,args.outputcat)
        
    logger.info('# Percentage of cat 1 matched : {} %'.format(100*(len(mergedcat)/len(catalogs[0]))))
    logger.info('# Percentage of cat 2 matched : {} %'.format(100*(len(mergedcat)/len(catalogs[1]))))
    logger.info('# Size ratio cat 2 / cat 1 : {} %'.format(100*(len(catalogs[1])/len(catalogs[0]))))



    logger.info('#')
    logger.info('# Exiting mergecatalogs mainMethod()')
    logger.info('#')
コード例 #13
0
ファイル: truewcs.py プロジェクト: rfahed/extProcess
def mainMethod(args):
    """
    @brief The "main" method.
    @details
        This method is the entry point to the program. In this sense, it is
        similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('truewcs')

    logger.info('#')
    logger.info('# Entering truewcs mainMethod()')
    logger.info('#')
    instrument = image.read_instrument(args.instrument)
    for imfile in args.images :
        im=fits.open(imfile)
        image.updatewcs(im,instrument)
        im.writeto('truewcs_'+imfile)
        

    logger.info('#')
    logger.info('# Exiting truewcs mainMethod()')
    logger.info('#')
コード例 #14
0
def mainMethod(args):
    """
    @brief The "main" method.
    @details
        This method is the entry point to the program. In this sense, it is
        similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('generate_weight_map')

    logger.info('#')
    logger.info('# Entering generate_weight_map mainMethod()')
    logger.info('#')

    # !! Getting the option from the example option in defineSpecificProgramOption
    # !! e.g string_option = args.string_value

    instrument=image.read_instrument(args.instrument)
    wmap=image.generate_weight_map(instrument)
    wmap.writeto(args.outfile,overwrite=True)

    logger.info('#')
    logger.info('# Exiting generate_weight_map mainMethod()')
    logger.info('#')
コード例 #15
0
ファイル: GetFiles.py プロジェクト: degauden/Elements
def mainMethod(args):
    """
    @brief The "main" method.
    @details This method is the entry point to the program. In this sense, it is
    similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('GetElementsFiles')

    exit_code = Exit.Code["OK"]

    stem = args.file_stem
    file_type = args.type

    if stem.find(os.path.sep) != -1 and (not Path.HAS_SUBLEVELS[file_type]):
        logger.error("The search stem cannot contain \"%s\" for the %s type", os.path.sep, file_type)
        exit_code = Exit.Code["NOT_OK"]

    locations = Path.getLocations(file_type, exist_only=True, with_defaults=args.with_defaults)

    if stem:
        found_list = Path.getAllPathFromLocations(stem, locations)
    else:
        logger.info("No stem provided. Listing all files")
        found_list = []
        for l in locations:
            for root, _, files in os.walk(l):
                for f in files:
                    found_list.append(os.path.join(root, f))

    found_list = selfFilter(found_list, args.self)

    for f in found_list:
        print(f)

    return exit_code
コード例 #16
0
def mainMethod(args):
    """ The "main" method.
    This method is the entry point to the program. In this sense, it is similar to a main
    (and it is why it is called mainMethod()). The code below contains the calls to the
    different classes created for the first developer's workshop. See the ElementsProgram
    documentation for more details.
    """
    logger = log.getLogger('SwigProgramExample')
    logger.info('Entering SwigProgramExample mainMethod()')

    #
    #  Log some of the arguments
    #
    int_from_configuration = args.int_option
    if not int_from_configuration:
        int_from_configuration = 9
    logger.info('Example int : %d', int_from_configuration)
    func_result = functionExample(int_from_configuration)
    logger.info('functionExample(%d) : %d', int_from_configuration,
                func_result)

    logger.info('Exiting SwigProgramExample mainMethod()')

    return Exit.Code["OK"]
コード例 #17
0
# along with this library; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#

import argparse
import os
from datetime import timedelta

import ElementsKernel.Logging as logging
import matplotlib.pyplot as plt
import numpy as np
from dateutil.parser import parse, parser as dateutil_parser
from matplotlib.ticker import FuncFormatter
from time import mktime

logger = logging.getLogger(__name__)


def _parse_sourcex_logs(path):
    """
    Low level parsing of the logs
    :param path:
        SourceX logs
    :return:
        A dictionary with the log entries, with their timestamp, logger, level and message
    """
    timestamp_parser = dateutil_parser()

    log = dict(timestamp=[], logger=[], level=[], message=[])
    with open(path) as fd:
        for line in fd:
コード例 #18
0
ファイル: RemoveCppClass.py プロジェクト: degauden/Elements
import argparse
import os
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import Logging
from ElementsKernel import Exit

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

CMAKE_LISTS_FILE = 'CMakeLists.txt'

logger = Logging.getLogger('RemoveCppClass')

################################################################################


def getAllFiles(class_name, module_directory, module_name):
    """
    Get all files related to a class
    """
    delete_file_list = []
    file_name_h = os.path.join(module_directory, module_name,
                               class_name) + '.h'
    if os.path.exists(file_name_h):
        delete_file_list.append(file_name_h)
    file_name_cpp = os.path.join(module_directory, 'src', 'lib',
                                 class_name) + '.cpp'
コード例 #19
0
from argparse import RawTextHelpFormatter

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import Logging

from ElementsKernel import Exit

CMAKE_LISTS_FILE = 'CMakeLists.txt'

logger = Logging.getLogger('RemovePythonProgram')

################################################################################


def getAllFiles(program_name, module_directory, module_name):
    """
    Get all files related to a python program
    """
    delete_file_list = []
    file_name_conf = os.path.join(module_directory, 'conf', module_name,
                                  program_name) + '.conf'
    if os.path.exists(file_name_conf):
        delete_file_list.append(file_name_conf)
    file_name_cpp = os.path.join(module_directory, 'python', module_name,
                                 program_name) + '.py'
コード例 #20
0
ファイル: NameCheck.py プロジェクト: degauden/Elements
import os
import argparse
import json

import ElementsKernel.Logging as log
from ElementsKernel import Exit

# pyling: disable=bare-except
try:
    from urllib2 import urlopen  # @UnusedImport @UnresolvedImport
    from urllib2 import URLError  # @UnusedImport @UnresolvedImport
except:  # pylint: disable=bare-except
    from urllib.request import urlopen  # @ImportRedefinition
    from urllib.error import URLError

logger = log.getLogger('NameCheck')

TYPES = ["cmake", "library", "executable"]
DEFAULT_TYPE = "cmake"

_localUrlOpen = urlopen


def getInfo(name, db_url, entity_type=DEFAULT_TYPE):
    """ Get the informations about a given entity of a specific type """
    full_url = db_url + "/NameCheck/exists?name=%s&type=%s" % (name,
                                                               entity_type)
    logger.debug("The url for the name request: %s", full_url)
    info = json.loads(_localUrlOpen(full_url).read().decode("utf-8"))
    for u in ["url", "private_url"]:
        if u in info and info[u]:
コード例 #21
0
ファイル: AddCppProgram.py プロジェクト: degauden/Elements
:date: 01/07/15


"""

import argparse
import os
import time
from ElementsKernel import Auxiliary
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeListsMacros
from ElementsKernel import Logging

from ElementsKernel import Exit

logger = Logging.getLogger('AddCppProgram')

# Define constants
CMAKE_LISTS_FILE = 'CMakeLists.txt'
PROGRAM_TEMPLATE_FILE = 'Program_template.cpp'
PROGRAM_TEMPLATE_FILE_IN = 'Program_template.cpp.in'


def createDirectories(module_dir):
    """
    Create directories needed for a program
    """

    standalone_directories = [os.path.join('src', 'program'), 'conf']
    for d in standalone_directories:
        target_dir = os.path.join(module_dir, d)
コード例 #22
0
def mainMethod(args):
    """
    @brief The "main" method.
    @details
        This method is the entry point to the program. In this sense, it is 
        similar to a main (and it is why it is called mainMethod()).
    """

    logger = log.getLogger('runwcsfit')

    logger.info('#')
    logger.info('# Entering runwcsfit mainMethod()')
    logger.info('#')

    wcsfit.IMCORE = args.imcore_path

    #if args.debug:
    #    logger.setLevel(logging.DEBUG)

    image_name = args.image

    if wcsfit.check_wcslib() == ERROR:
        sys.exit(1)

    if wcsfit.check_exe_in_path() == ERROR:
        sys.exit(1)

    # Check number of extensions and merge quadrants into ccd image if necessary
    n_extensions = wcsfit.get_number_of_extensions(image_name)
    if n_extensions in (4, 144):  # Quadrants
        wcsfit.merge_quadrants(image_name)
        image_name = image_name.replace('.fit', '_ccd.fit')
    elif n_extensions in (1, 36):  # CCD
        pass
    else:
        logger.error(
            'fits file does not contain correct number of extensions ({})'.
            format(n_extensions))
        sys.exit(1)

    # Deal with the weight map if needed
    if args.weight.find('noconf') == -1:
        weight_name = args.weight
        n_extensions = wcsfit.get_number_of_extensions(image_name)
        if n_extensions in (4, 144):  # Quadrants
            wcsfit.merge_quadrants(weight_name)
            weight_name = weight_name.replace('.fit', '_ccd.fit')
        wcsfit.weight_to_conf(image_name, weight_name)

    # Fit astrometry
    with wcsfit.CCDImage(image_name, mode=args.mode,
                         save_backup=args.copy) as img:
        img.fit_astrometry(refcat=args.refcat,
                           makecat=args.nocat,
                           wcsconf=args.wcsconf,
                           fitpv=args.fitpv)

    # Primt summary
    print_summary(image_name)

    logger.info('#')
    logger.info('# Exiting runwcsfit mainMethod()')
    logger.info('#')
コード例 #23
0
"""

import argparse
import os
import time

from ElementsKernel import Auxiliary
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import ParseCmakeListsMacros
from ElementsKernel import Logging

from ElementsKernel import Exit

logger = Logging.getLogger('AddPythonProgram')

# Define constants
CMAKE_LISTS_FILE = 'CMakeLists.txt'
PROGRAM_TEMPLATE_FILE = 'PythonProgram_template.py'
PROGRAM_TEMPLATE_FILE_IN = 'PythonProgram_template.py.in'

################################################################################


def createDirectories(module_dir, module_name):
    """
    Create directories needed for a python program
    """
    standalone_directories = [
        os.path.join('python', module_name),
コード例 #24
0
@file tests/python/smoke_test.py
@date 12/16/15
@author user
"""
import py.test
import os.path
import glob
import extSim.utils
import extSim.extsim
from astropy.io import fits
import shutil
from string import uppercase as amptags
from fixtures.PyDataSyncFixture import *
import ElementsKernel.Logging as logging

log = logging.getLogger('image')

data_dir = os.path.join(os.environ["PHOTROOT"],"tests", "data")

def symlinks(datafiles,workspace):
    for dst,src in datafiles.items():
        os.symlink(os.path.join(data_dir,src), os.path.join(workspace,dst))

def simulate():
    datafiles={"catalog.txt":"myEXTrandomcat-sersics.txt", "target.json":"des_target.json", "instrument.json":"des_test_instrument.json", "flat.fits":"des_testflat.fits", "bias.fits":"des_testbias.fits"}
    with extSim.utils.mock_workspace('test_smoke_sersics_ws_',del_tmp=False) as workspace:
       symlinks(datafiles,workspace)
       args = extSim.extsim.parseOptions(['--workspace',workspace],defaultconfig='smoke_test.conf')
       extSim.extsim.mainMethod(args)
    return args
コード例 #25
0
ファイル: AddModule.py プロジェクト: degauden/Elements
import argparse
import os

from ElementsKernel import Exit
from ElementsKernel import Auxiliary
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import ParseCmakeListsMacros
from ElementsKernel import Logging

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

logger = Logging.getLogger('AddElementsModule')

# Define constants
CMAKE_LISTS_FILE = 'CMakeLists.txt'
CMAKE_LISTS_FILE_IN = 'CMakeLists.txt.mod.in'
AUX_MOD_RST_IN = 'doc_module.rst.in'

target_locations = {
    CMAKE_LISTS_FILE_IN: "CMakeLists.txt",
    AUX_MOD_RST_IN: "doc/doc_module.rst"
}

################################################################################


def checkCmakelistFileExist(project_directory):
コード例 #26
0
:date: 01/07/15

"""

import os
import argparse
import time
from ElementsKernel import Auxiliary
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import Logging

from ElementsKernel import Exit

logger = Logging.getLogger('AddPythonModule')

# Define constants
CMAKE_LISTS_FILE = 'CMakeLists.txt'
PYTEST_TEMPLATE_FILE_IN = 'PythonTest_template.py.in'
PYMODULE_TEMPLATE_FILE_IN = 'PythonModule_template.py.in'

################################################################################


def createDirectories(module_dir, module_name):
    """
    Create directories needed for a python module
    """
    standalone_directories = [
        os.path.join('python', module_name),
コード例 #27
0
import os
import re

import ELEMENTS_VERSION  # @UnresolvedImport

import ElementsKernel.Logging as log
from ElementsKernel import Auxiliary
from ElementsKernel import ProjectCommonRoutines

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

logger = log.getLogger('CreateElementsProject')

AUX_CMAKE_LIST_IN = "CMakeLists.txt.in"
AUX_MAKE_FILE_IN = "Makefile.in"
AUX_PROJ_RST_IN = "doc_project.rst.in"
AUX_PROJ_MAINPAGE_IN = "mainpage.dox.in"
AUX_GITIGNORE_IN = "gitignore_template.in"
AUX_GITATTRIBUTES_IN = "gitattributes_template.in"
AUX_EDITOR_CONFIG = "editorconfig"
AUX_CLANG_FORMAT = "clang-format"

target_locations = { AUX_CMAKE_LIST_IN: "CMakeLists.txt",
                     AUX_MAKE_FILE_IN: "Makefile",
                     AUX_PROJ_RST_IN: "doc/doc_project.rst",
                     AUX_PROJ_MAINPAGE_IN: "doc/mainpage.dox",
                     AUX_GITIGNORE_IN: ".gitignore",
コード例 #28
0
import ElementsKernel.Auxiliary as aux

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

# Define a global list containing files created or modified
# by the python scripts for the creation of a Elements project
_filelist = []

# Define regex for name & version checking
NAME_REGEX = r"^[A-Za-z0-9][A-Za-z0-9_-]*$"
VERSION_REGEX = r"^(\d+\.\d+(\.\d+)?|HEAD)$"

logger = log.getLogger('ProjectCommonRoutines')

CMAKE_LISTS_FILE = 'CMakeLists.txt'


################################################################################
def addItemToCreationList(element):
    """
    Add an element to the global list.
    """
    _filelist.append(element)


################################################################################
def printCreationList():
    """
コード例 #29
0
ファイル: image.py プロジェクト: rfahed/extProcess
"""
@file python/Phot/photometry.py
@date 03/16/16
@author user
"""
from __future__ import division
import ElementsKernel.Logging as log
logger = log.getLogger('image')
import subprocess, os, sys
from . import utils
from astropy.io import fits
from astropy.modeling import models, fitting
from astropy.wcs import WCS
from matplotlib.colors import LogNorm
import numpy as np
import numpy.ma as ma
from string import Template
from matplotlib import pylab as P
import json
from scipy.ndimage.measurements import center_of_mass


def parse_section_list(sectionlist):
    section = [sys.maxint, 0, sys.maxint, None]
    for sectionstring in sectionlist :
        s = parse_section_string(sectionstring)
        section = [min(s[0], section[0]), max(s[1],section[1]), min(s[2],section[2]), max(s[3],section[3])]
    return section

def parse_section_string(section):
    section=section[1:-1].replace(':',',').split(',')
コード例 #30
0
import argparse
import os
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import Logging

from ElementsKernel import Exit

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

CMAKE_LISTS_FILE = 'CMakeLists.txt'

logger = Logging.getLogger('RemovePythonModule')

################################################################################


def getAllFiles(pymodule_name, module_directory, module_name):
    """
    Get all files related to a python module
    """
    delete_file_list = []
    file_name_test = os.path.join(module_directory, 'tests', 'python', \
                                   pymodule_name) + '_test.py'
    if os.path.exists(file_name_test):
        delete_file_list.append(file_name_test)
    file_name_py = os.path.join(module_directory, 'python', module_name, \
                                 pymodule_name) + '.py'
コード例 #31
0
ファイル: AddScript.py プロジェクト: degauden/Elements
:date: 03/08/17

"""

import argparse
import os
import time
import stat
from ElementsKernel import Auxiliary
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import Logging

from ElementsKernel import Exit

logger = Logging.getLogger('AddScript')

# Define constants
CMAKE_LISTS_FILE = 'CMakeLists.txt'
PROGRAM_TEMPLATE_FILE = 'Script_template'
PROGRAM_TEMPLATE_FILE_IN = 'Script_template.in'

################################################################################


def createDirectories(module_dir):
    """
    Create directories needed for a python program
    """
    # Create the scripts directory
    scripts_path = os.path.join(module_dir, 'scripts')
コード例 #32
0
ファイル: Program.py プロジェクト: degauden/Elements
 def _setupLogging(arg_parser):
     options = arg_parser.parse_known_args()[0]
     if options.log_level:
         log.setLevel(options.log_level.upper())
     if options.log_file:
         log.setLogFile(options.log_file)
コード例 #33
0
ファイル: RemoveCppProgram.py プロジェクト: degauden/Elements
import argparse
import os
from ElementsKernel import ProjectCommonRoutines
from ElementsKernel import ParseCmakeLists
from ElementsKernel import Logging
from ElementsKernel import Exit

try:
    from builtins import input
except ImportError:
    from __builtin__ import input

CMAKE_LISTS_FILE = 'CMakeLists.txt'

logger = Logging.getLogger('RemoveCppProgram')

################################################################################


def getAllFiles(program_name, module_directory, module_name):
    """
    Get all files related to a Cpp program
    """
    delete_file_list = []
    file_name_conf = os.path.join(module_directory, 'conf', module_name,
                                  program_name) + '.conf'
    if os.path.exists(file_name_conf):
        delete_file_list.append(file_name_conf)
    file_name_cpp = os.path.join(module_directory, 'src', 'program',
                                 program_name) + '.cpp'