Exemplo n.º 1
0
    def load(self, jf):
        """ jf:  json file object """
        jdata = _json_load(jf)
        try:
            first_money = jdata[0]
            if type(first_money) != int:
                raise FirstMoneyNotFoundException('First Money Not Found')
            del(jdata[0])
        except IndexError:
            raise FirstMoneyNotFoundException('First Money Not Found')

        kakebo = Kakebo(first_money)

        while jdata:
            try:
                date = _parse_date(jdata[0])
            except IllegalDateException as e:
                stderr.write(e)
            daily = Daily(date)
            del(jdata[0])

            for a_content in jdata[0]:
                s_content, income = a_content
                ignore_statics = False
                if s_content.startswith('#') is True:
                    ignore_statics = True
                content = Content(
                    s_content, income, ignore_statics=ignore_statics)
                daily.append(content)
            del(jdata[0])
            kakebo.append(daily)
        return kakebo
Exemplo n.º 2
0
def json_read(path, **kwargs):
    """
    Read a JSON file.

    Args:
        path (path-like object): Path to file to load.
        kwargs: "json.load" kwargs.

    Returns:
        dict or list: Un-serialized content
    """
    with open(_fsdecode(path), 'rt') as file:
        return _json_load(file, **kwargs)
Exemplo n.º 3
0
def _load():
    if _path.isfile(_file_path):
        loaded_configuration = {}
        try:
            with open(_file_path, 'r') as config_file:
                loaded_configuration = _json_load(config_file)
        except Exception:
            _log.error('failed to load from %s', _file_path)

        # loaded_configuration.update(_configuration)
        _configuration.clear()
        _configuration.update(loaded_configuration)

    if _log.isEnabledFor(_DEBUG):
        _log.debug('load => %s', _configuration)

    _cleanup(_configuration)
    _configuration[_KEY_VERSION] = __version__
    return _configuration
Exemplo n.º 4
0
def _load():
	if _path.isfile(_file_path):
		loaded_configuration = {}
		try:
			with open(_file_path, 'r') as config_file:
				loaded_configuration = _json_load(config_file)
		except:
			_log.error("failed to load from %s", _file_path)

		# loaded_configuration.update(_configuration)
		_configuration.clear()
		_configuration.update(loaded_configuration)

	if _log.isEnabledFor(_DEBUG):
		_log.debug("load => %s", _configuration)

	_cleanup(_configuration)
	_configuration[_KEY_VERSION] = __version__
	return _configuration
Exemplo n.º 5
0
def json_read(path, **kwargs):
    """
    Read a JSON file.

    Args:
        path (path-like object): Path to file to load.
        kwargs: "json.load" kwargs.

    Returns:
        dict or list: Un-serialized content
    """
    path = _realpath(_fsdecode(path))
    with open(path, 'rt') as file:
        try:
            return _json_load(file, **kwargs)

        except _JSONDecodeError as exception:
            raise _ConfigurationException(
                f'Unable to read "{path}": {str(exception)}')
Exemplo n.º 6
0
def read_json(file_path: str) -> _tmc_dict:

    d = {}
    valid_keys = ['probability', 'state_from', 'state_to']

    with open(file_path, mode='r') as file:

        file.seek(0)

        data = _json_load(file)

        if not isinstance(data, list):  # pragma: no cover
            raise ValueError('The file format is not compliant.')

        for obj in data:

            if not isinstance(obj, dict):  # pragma: no cover
                raise ValueError('The file format is not compliant.')

            if sorted(obj.keys()) != valid_keys:  # pragma: no cover
                raise ValueError('The file contains invalid elements.')

            state_from = obj['state_from']
            state_to = obj['state_to']
            probability = obj['probability']

            if not isinstance(state_from,
                              str) or len(state_from) == 0:  # pragma: no cover
                raise ValueError('The file contains invalid elements.')

            if not isinstance(state_to,
                              str) or len(state_to) == 0:  # pragma: no cover
                raise ValueError('The file contains invalid elements.')

            if not isinstance(
                    probability,
                (float, int, _np.floating, _np.integer)):  # pragma: no cover
                raise ValueError('The file contains invalid elements.')

            d[(state_from, state_to)] = float(probability)

    return d
Exemplo n.º 7
0
def pytest_generate_tests(metafunc):

    module = metafunc.module.__name__
    func = metafunc.definition.name
    mark = metafunc.definition.get_closest_marker('parametrize')
    names = metafunc.fixturenames

    test_index = module.find('_') + 1
    test_name = module[test_index:]

    if test_name not in _fixtures:

        base_directory = _os_abspath(_os_dirname(__file__))
        fixtures_file = _os_join(base_directory,
                                 f'fixtures/fixtures_{test_name}.json')

        if not _os_isfile(fixtures_file):
            _fixtures[test_name] = None
        else:

            with open(fixtures_file, 'r') as file:
                fixture = _json_load(file)
                fixture = _sanitize_fixture_recursive(fixture, _replacements)
                _fixtures[test_name] = fixture

    fixture = _fixtures[test_name]

    values = []
    ids = []

    if len(names) > 0 and mark is None and fixture is not None and len(
            fixture) > 0:

        if isinstance(fixture, dict):
            values, ids = _parse_fixture_dictionary(fixture, names, func)
        elif isinstance(fixture, list):
            values, ids = _parse_fixture_list(fixture, names, func)

    metafunc.parametrize(names, values, False, ids)
# </editor-fold>

# <editor-fold desc="Loads and declarations">
_this_module = _sys_modules[__name__]
_classmap = _get_classmap()

_command_manager = stdout_redirected

_DISKFULL_RE = _re_compile('Disk Full')

_ID = 'OpendssdirectEnhancer'
setattr(_this_module, 'utils', _odr.utils)

# loads chains of functions through which to pass the rough outputs of opendss.
with open(TREATMENTS_PATH, 'r') as _tfile:
    _rtrt = _json_load(_tfile)
_trt = dict()
for _subdic_name, _subdic in _rtrt.items():
    _nsd = {
        k: tuple([globals()[_t] for _t in _v])
        for k, _v in _subdic.items()
    }
    _trt[_subdic_name] = _nsd

# loads measurement units for the interface of components without self-referencing.
# the components with self referencing, like lines and loadshapes, are taken care of at runtime.
with open(UNIT_MEASUREMENT_PATH, 'r') as _ufile:
    _rumr = _json_load(_ufile)
_umr = dict()
for _subdic_name, _subdic in _rumr.items():
    _nsd = {_k: _UM.parse_units(_v) for _k, _v in _subdic.items()}
Exemplo n.º 9
0
def json_load(filename):
    can_read_file(filename)
    with open(filename, 'r') as f:
        res = _json_load(f)
    return res
Exemplo n.º 10
0
def main():
    parser = get_option_parser()
    (options, filenames) = parser.parse_args()
    print(options._in)

    if len(filenames) >= 3:
        error('Filenames are too many.')

    if options._in:
        filename = filenames[0]
        with open(filename) as jf:
            sudokus = _json_load(jf)
        sudokus.append(get_entered_sudoku())
        with open(filename, 'w') as jf:
            _json_dump(sudokus, jf, indent=4)
        print('Done')
    return

    show_page_number = not(bool(options.hidden_page_number))
    show_title = not(bool(options.hidden_title))
    if options.out_filename is None:
        out_filename = os.path.splitext(filenames[0])[0] + '.pdf'
    else:
        out_filename = options.out_filename

    if options.problem_name is None:
        problem_name = 'Problem'
    else:
        problem_name = options.problem_name

    if options.answer_name is None:
        answer_name = 'Answer'
    else:
        answer_name = options.answer_name

    c = canvas.Canvas(
        out_filename, bottomup=False)

    if len(filenames) == 1:  # case: only problem files
        json_filename = filenames[0]
        try:
            with open(json_filename) as f:
                sudokus = Sudoku.load(f)
        except IOError:
            error('Filename {} is not found.'.format(json_filename))
        except ValueError:
            error('Illegal format')

        page_infos = []
        for j, sudoku in enumerate(sudokus):
            page_infos.append(SudokuPageInfo(sudoku, '{} {}'.format(
                problem_name, j + 1),
                show_page_number=show_page_number,
                show_title=show_title,
                page_number=j + 1))

    elif len(filenames) == 2:
        prob_filename, ques_filename = filenames
        try:
            with open(prob_filename) as f:
                prob_sudokus = Sudoku.load(f)
        except IOError:
            error('Filename {} is not found.'.format(prob_filename))
        except ValueError:
            error('Illegal format')

        try:
            with open(ques_filename) as f:
                ques_sudokus = Sudoku.load(f)
        except IOError:
            error('Filename {} is not found'.format(ques_filename))
        except ValueError:
            error('Illegal format')

        page_infos = []
        page_number = 1
        for j, sudoku in enumerate(prob_sudokus):
            page_infos.append(
                SudokuPageInfo(sudoku, '{} {}'.format(problem_name, j + 1),
                               show_page_number=show_page_number,
                               show_title=show_title,
                               page_number=page_number))
            page_number += 1
        for j, sudoku in enumerate(ques_sudokus):
            page_infos.append(
                SudokuPageInfo(sudoku, '{} {}'.format(answer_name, j + 1),
                               show_page_number=show_page_number,
                               show_title=show_title,
                               page_number=page_number))
            page_number += 1

    for i, page_info in enumerate(page_infos):
        page_info.write_pdf(c)
        if i != len(page_infos) - 1:
            c.showPage()

    c.save()
Exemplo n.º 11
0
def load_json_from_file(file_path: str) -> str:
    result = None
    with open(file_path) as fp:
        result = _json_load(fp)
    return result
Exemplo n.º 12
0
from json import load as _json_load
import os
from typing import Dict

import utils


PWD = os.getcwd()
if (os.path.sep + 'src') in PWD:
    PWD = os.path.join(os.getcwd(), "pss_data")
else:
    PWD = os.path.join(os.getcwd(), "src", "pss_data")

ID_NAMES_FILEPATH = os.path.join(PWD, "id_names.json")

ID_NAMES_INFO: Dict[str, str]

with open(ID_NAMES_FILEPATH) as fp:
    ID_NAMES_INFO = _json_load(fp)