fclmodule.cxx File Reference

#include "Python.h"
#include <iostream>
#include <iomanip>
#include <sstream>
#include "cetlib/search_path.h"
#include "cetlib_except/exception.h"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/ParameterSetWalker.h"
#include "fhiclcpp/ParameterSetRegistry.h"
#include "fhiclcpp/make_ParameterSet.h"

Go to the source code of this file.

Classes
class	PythonDictConverter

Macros
#define	PY_SSIZE_T_CLEAN

Functions
static std::string	format (PyObject *obj, unsigned int pos, unsigned int indent, unsigned int maxlen, unsigned int depth)
static PyObject *	make_pset (PyObject *self, PyObject *args)
static PyObject *	pretty (PyObject *self, PyObject *args)
void	initfcl ()

Variables
static struct PyMethodDef	fclmodule_methods []

Macro Definition Documentation

#define PY_SSIZE_T_CLEAN

Definition at line 51 of file fclmodule.cxx.

Function Documentation

static std::string format ( PyObject *  obj, unsigned int  pos, unsigned int  indent, unsigned int  maxlen, unsigned int  depth  )

static

Definition at line 374 of file fclmodule.cxx.

{
  // Result string stream.

  std::ostringstream ss;

  if(PyBytes_Check(obj)) {

    // String objects, add double quotes, but don't do any other formatting.

    ss << "\"" << PyBytes_AsString(obj) << "\"";
  }

  else if(PyUnicode_Check(obj)) {

    // Unicode objects, convert to byte string and add double quotes.

    PyObject* bytes = PyUnicode_AsUTF8String(obj);
    ss << "\"" << PyBytes_AsString(bytes) << "\"";
  }

  else if(PyDict_Check(obj)) {

    // Always print dictionary objects in multiline format, one key per line.

    // Get list of keys.  Keys are assumed to be strings.

    PyObject* keys = PyDict_Keys(obj);

    // Make a first pass over the list of keys to determine the maximum length key.

    int n = PyList_Size(keys);
    int keymaxlen = 0;
    for(int i=0; i<n; ++i) {
      PyObject* key = PyList_GetItem(keys, i);
      int keylen = python_string_len(key);
      if(keylen > keymaxlen)
        keymaxlen = keylen;
    }

    // Print enclosing braces, but not for outermost table (i.e. the whole parameter set).

    bool outer = (pos == 0 && indent == 0);
    if(!outer && n != 0)
      ss << "{\n";

    // Second pass, loop over keys and values and convert them to strings.

    for(int i=0; i<n; ++i) {
      PyObject* key = PyList_GetItem(keys, i);
      PyObject* value = PyDict_GetItem(obj, key);
      std::string ks = python_to_cxx_str(key);
      ss << std::setw(indent) << ""
         << std::setw(keymaxlen) << std::left << ks << " : "
         << format(value, indent + keymaxlen + 3, indent+2, maxlen, depth+1)
         << '\n';
    }
    if(n == 0)
      ss << "{}";
    else if(!outer)
      ss << std::setw(indent-1) << std::right << '}';

    Py_DECREF(keys);

  }

  else if(PyList_Check(obj) || PyTuple_Check(obj)) {

    // Sequence printing handled here.
    // Break lines only when position exceeds maxlen.

    char open_seq = 0;
    char close_seq = 0;
    int n = 0;
    if(PyList_Check(obj)) {
      open_seq = '[';
      close_seq = ']';
      n = PyList_Size(obj);
    }
    else {
      open_seq = '(';
      close_seq = ')';
      n = PyTuple_Size(obj);
    } 

    // Loop over elements of this sequence.

    std::string sep(1, open_seq);
    unsigned int break_indent = pos+1;
    for(int i=0; i<n; ++i) {
      ss << sep;
      pos += sep.size();
      PyObject* ele = PySequence_GetItem(obj, i);

      // Get the formatted string representation of this object.

      std::string f = format(ele, pos, break_indent, maxlen, depth+1);

      // Get the number of characters before the first newline.

      std::string::size_type fs = f.size();
      std::string::size_type n1 = std::min(f.find('\n'), fs);

      // Decide if we want to break the line before printing this element.
      // Never break at the first element of a sequence.
      // Force a break (except at first element) if this is a structured element.
      // If we do break here, reformat this element with the updated position.

      bool force_break = PyList_Check(ele) || PyTuple_Check(ele) || PyDict_Check(ele);
      if(i > 0 && (force_break || pos + n1 > maxlen)) {
        ss << '\n' << std::setw(break_indent) << "";
        pos = break_indent;
        f = format(ele, pos, break_indent, maxlen, depth+1);
        fs = f.size();
      }

      // Print this element

      ss << f;

      // Update the current character position, taking into account 
      // whether the string we just printed contains a newline.

      std::string::size_type n2 = f.find_last_of('\n');
      if(n2 >= fs)
        pos += fs;
      else
        pos = fs - n2 - 1;

      sep = std::string(", ");
      Py_DECREF(ele);
    }

    // Close sequence.

    if(n == 0)
      ss << open_seq;
    ss << close_seq;
  }

  else {

    // Last resort, use python's string representation.

    PyObject* pystr = PyObject_Str(obj);
    std::string s = python_to_cxx_str(pystr);

    // Print booleans in lower case instead of python default case.

    if(s == std::string("True"))
      s = "true";
    else if(s == std::string("False"))
      s = "false";
    ss << s;
  }

  // Done.

  return ss.str();
}

void initfcl

(

)

Definition at line 665 of file fclmodule.cxx.

  {
    Py_InitModule("fcl", fclmodule_methods);
  }

static PyObject* make_pset ( PyObject *  self, PyObject *  args  )

static

Definition at line 558 of file fclmodule.cxx.

{
  // Extract argument as string.

  const char* fclname;
  if(!PyArg_ParseTuple(args, "s", &fclname))
    return 0;
  std::string fclstr(fclname);

  // Make parameter set.

  PyObject* result = 0;
  try {
  std::string pathvar("FHICL_FILE_PATH");
  cet::filepath_lookup maker(pathvar);
    auto pset = fhicl::ParameterSet::make(fclstr, maker);
    PythonDictConverter converter;
    pset.walk(converter);
    result = converter.result();
  }
  catch(cet::exception& e) {
    PyErr_SetString(PyExc_IOError, e.what());
    result = 0;
  }

  // Done.

  return result;
}

static PyObject* pretty ( PyObject *  self, PyObject *  args  )

static

Definition at line 596 of file fclmodule.cxx.

{
  // Result.

  PyObject* result = 0;

  // Extract argument.

  int n = PySequence_Length(args);
  if(n == 0) {

    // No arguments, return none.

    result = Py_None;
    Py_INCREF(result);
  }
  else {

    // Otherwise, extract the first element.

    PyObject* obj = PySequence_GetItem(args, 0);
    std::string s = format(obj, 0, 0, 80, 0);
    result = cxx_str_to_python(s);
  }

  // Done.

  return result;
}

Variable Documentation

struct PyMethodDef fclmodule_methods[]

static

Initial value:

= {
  {"make_pset", make_pset, METH_VARARGS, "Convert fcl ParameterSet to python dictionary"},
  {"pretty", pretty, METH_VARARGS, "Convert dictionary parameter set to fcl text"},
  {0, 0, 0, 0}
}

Definition at line 638 of file fclmodule.cxx.