Homec4science
Diffusion py-licenser (licence_header_only) Browse

py-licenser/pylicenser/file_info.py
f4033ce0bc96licence_header_only

Last Change
Raw File

file_info.py
View Options

# -*- coding: utf-8 -*-
""" file_info.py: Per file type specialisation of the code"""
__author__ = "Guillaume Anciaux and Nicolas Richart"
__credits__ = [
"Guillaume Anciaux <guillaume.anciaux@epfl.ch>",
"Nicolas Richart <nicolas.richart@epfl.ch>",
]
__copyright__ = "Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale" \
" de Lausanne) Laboratory (LSMS - Laboratoire de Simulation" \
" en Mécanique des Solides)"
__license__ = "GPLv3"
__version__ = "2.0"
import os
import re
import jinja2
import copy
from . import export
UNKNOWN_TYPE = 0
CPP_SOURCES = 1
CMAKE_FILES = 2
SWIG_FILES = 3
PYTHON_SCRIPT = 4
CREATION_MODIFICATION = 0
LAST_MODIFICATION = 1
CREATION = 2
@export
class FileInfo:
__date_style_conv = {'creation_modification': CREATION_MODIFICATION,
'last_modification': LAST_MODIFICATION,
'creation': CREATION}
__supported_ext = []
__supported_types = {
CPP_SOURCES: [".cc", ".c", ".hh", ".h"],
CMAKE_FILES: [".txt", ".cmake"],
SWIG_FILES: [".i"],
PYTHON_SCRIPT: [".py"]}
_file_type = UNKNOWN_TYPE
_file_content = ""
_warn_list = list()
_brief = ""
_sections = list()
_authors = set()
_header = ""
def __init__(self, filename):
self._warn_list = list()
self._sections = list()
self._authors = set()
self._filename = os.path.expanduser(filename)
garbage, self._ext = os.path.splitext(os.path.basename(filename))
if self._ext == '.in':
self._ext = os.path.splitext(garbage)[1]
for key, value in self.__supported_types.items():
self.__supported_ext.extend(value)
if self._ext not in self.__supported_ext:
raise NotImplementedError(
"File {0} has been skipped based on its extension".format(
self._filename))
for key, value in self.__supported_types.items():
if self._ext in value:
self._file_type = key
self.__analyse_content()
def __analyse_content(self):
with open(self._filename) as f:
self._file_content = f.read()
try:
self.__split_header()
except Exception as error:
raise Exception(
"While dealing with file {0}:\n{1}".format(self._filename,
error))
self.__find_authors()
self.__find_brief()
self.__save_sections()
if self._warn_list:
print("\nWARNING!:")
print(" While dealing with file {0}".format(self._filename))
print(" the following shit happened:")
[print(" {0}".format(warning)) for warning in self._warn_list]
print("{0}:1:".format(self._filename))
def __save_sections(self):
reg = re.compile('^(.*@section)', re.MULTILINE)
pref = re.search(reg, self._header)
pref = pref.group(1) if pref is not None else ""
reg = re.compile('^.*@section', re.MULTILINE)
licreg = re.compile('LICEN.E')
for section in re.split(reg, self._header)[1:]:
if not re.search(licreg, section.split('\n')[0]):
self._sections.append(pref + section)
def __split_header(self):
self.__pre_header = ""
if not re.search("(section LICENSE|[Cc]opyright)", self._file_content):
self._header = ""
self._body = self._file_content
print("This file as no header or a really badly formatted one!!")
else:
if self._file_type in [CPP_SOURCES, SWIG_FILES]:
self._header, self._body = re.split(
r"\*/", self._file_content, maxsplit=1)
self._header = '\n'.join(
(line for line in self._header.split('\n') if line.strip()))
elif self._file_type == CMAKE_FILES:
lines = self._file_content.split('\n')
nb_sep = 0
nb_whitelines = 0
header_lines = list()
while nb_sep < 2:
if lines[0].strip().startswith('#===='):
nb_sep += 1
elif not lines[0].strip():
nb_whitelines += 1
header_lines.append(lines.pop(0))
if nb_whitelines > 0:
self._warn_list.append(
"The header has a blank line or is ill-formed")
self._header = "\n".join(header_lines)
self._body = "\n".join(lines)
elif self._file_type == PYTHON_SCRIPT:
_pre_header_re = re.compile(r"^(#.*\n)*", re.MULTILINE)
matches = _pre_header_re.match(self._file_content)
if matches:
self.__pre_header = matches.group().strip()
self._body = copy.copy(self._file_content)
self._body = self._body.replace(self.__pre_header, '').strip()
self._header = ''
reg_doc_string = re.compile(
r"""(?P<docstring>["']{3}""" +
r"""(?:\s*(?P<filename>.*?):\s*)""" +
r"""(?P<brief>(?:.|\n)*?)["']{3})?\n*""",
re.MULTILINE)
match = reg_doc_string.search(self._body)
if match:
self._header = self._header + match.group(0)
reg_key_value = re.compile(
r"""(?P<key_value>(?P<keyword>""" +
r"""__(?:license|author|credits|copyright)__)""" + # NOQA: E501, keywords
r"""\s*=(?P<value>(?:(?P<brace>\s*(\[|\()\n?)?""" + # NOQA: E501, opening braces
r"""(?:\s*".*"\s*(?:\\|,)?\n?)+""" + # NOQA: E501, value, multiline or comma separated
r"""(?(brace)\s*(\]|\))\n))?))\n*""", # NOQA: E501, closing braces if opening present
re.MULTILINE)
for match in re.finditer(reg_key_value, self._body):
self._header = self._header + match.group(0)
self._body = self._body.replace(self._header, '')
def __find_authors(self):
if self._file_type == PYTHON_SCRIPT:
reg = re.compile(
r"__credits__ = \[(?P<names>(?:\s*\"(.*?)\",?\n?)*)\]") # NOQA(E501)
matches = reg.search(self._header)
if matches:
names = matches.group('names').strip()
reg = re.compile(
r"\"(?P<firstname>\w+)\s*(?P<lastname>\w+?)(?:\s*<(?P<email>.*?)>)?\"") # NOQA(E501)
else:
reg = re.compile(
r'@author\s+(?P<firstname>\w+)(?:\w|\s|\d|\.)*\s+(?P<lastname>\w+)(?:\s+<(?P<email>.+@.+\..+)>)?', # NOQA(E501)
re.IGNORECASE)
def __find_brief(self):
if self._file_type == PYTHON_SCRIPT:
_brief_re = re.compile(
r"(?P<docstring>[\"']{3}(?:\s*(?P<filename>.*?):\s*)(?P<brief>.*?)[\"']{3})", # NOQA(E501)
re.MULTILINE | re.DOTALL)
matches = _brief_re.match(self._header)
if matches:
_brief = ' '.join(
[line.strip() for line in
matches.group('brief').split('\n')])
else:
_brief = ""
return
if self._file_type in [CPP_SOURCES, SWIG_FILES]:
prefix = " *"
elif self._file_type == CMAKE_FILES:
prefix = "#"
else:
raise IOError("file type unknown")
reg = re.compile(
'@brief(.*?)^ ?\S\s+(@|Copyright)', re.MULTILINE | re.DOTALL)
matches = [match for match in re.finditer(reg, self._header)]
if len(matches) == 0:
self._brief = ""
return
if len(matches) > 1:
self._warn_list.append("There's multiple @brief")
_brief = "\n".join((line.replace(prefix, "").strip() for line in
matches[0].group(1).split('\n')
if len(line.strip()) > 1))
def generate_header(self, **kwargs):
args = copy.copy(kwargs)
args['filename'] = os.path.basename(self._filename)
args['pre_header'] = self.__pre_header
args['sections'] = self._sections
if self._file_type in [CPP_SOURCES, SWIG_FILES]:
template_file = 'cpp.j2'
elif self._file_type == CMAKE_FILES:
template_file = 'cmake.j2'
elif self._file_type == PYTHON_SCRIPT:
template_file = 'python.j2'
env = jinja2.Environment(
loader=jinja2.FileSystemLoader('pylicenser/header_templates/'),
trim_blocks=True,
undefined=jinja2.DebugUndefined
)
template = env.get_template(template_file)
return template.render(args)
def replace_file(self, new_header=None):
if new_header is None:
new_header = self._header
body = self._body.split("\n")
while body and not body[0].strip():
body.pop(0)
new_file = (new_header + '\n\n' +
'\n'.join(body))
if self._file_type == PYTHON_SCRIPT:
new_file = new_file + '\n' # ensure new line at the end W292
with open(self._filename, "w") as fh:
print(new_file, file=fh, end='')
c4science · Help