jmplace/DocScoDoc
1
0
Fork 0
forked from ScoDoc/DocScoDoc
Code Issues Pull Requests Projects Releases Wiki Activity
3254093b95
DocScoDoc/app/scodoc/sco_excel.py

777 lines
26 KiB
Python
Raw Blame History

# -*- mode: python -*-
# -*- coding: utf-8 -*-
##############################################################################
#
# Gestion scolarite IUT
#
# Copyright (c) 1999 - 2021 Emmanuel Viennet. All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Emmanuel Viennet emmanuel.viennet@viennet.net
#
##############################################################################
""" Excel file handling
"""
import datetime
import io
import time
from enum import Enum
from tempfile import NamedTemporaryFile
import openpyxl.utils.datetime
from openpyxl import Workbook, load_workbook
from openpyxl.cell import WriteOnlyCell
from openpyxl.styles import Font, Border, Side, Alignment, PatternFill
import app.scodoc.sco_utils as scu
from app.scodoc import notesdb
from app.scodoc import sco_preferences
from app.scodoc.notes_log import log
from app.scodoc.sco_exceptions import ScoValueError
class COLORS(Enum):
BLACK = "FF000000"
WHITE = "FFFFFFFF"
RED = "FFFF0000"
BROWN = "FF993300"
PURPLE = "FF993366"
BLUE = "FF0000FF"
ORANGE = "FFFF3300"
LIGHT_YELLOW = "FFFFFF99"
def send_excel_file(request, data, filename, mime=scu.XLSX_MIMETYPE):
"""publication fichier.
(on ne doit rien avoir émis avant, car ici sont générés les entetes)
"""
filename = (
scu.unescape_html(scu.suppress_accents(filename))
.replace("&", "")
.replace(" ", "_")
)
request.RESPONSE.setHeader("content-type", mime)
request.RESPONSE.setHeader(
"content-disposition", 'attachment; filename="%s"' % filename
)
return data
# Un style est enregistré comme un dictionnaire qui précise la valeur d'un attributdans la liste suivante:
# font, border, number_format, fill, .. (cf https://openpyxl.readthedocs.io/en/stable/styles.html#working-with-styles)
# (stolen from xlrd)
# Convert an Excel number (presumed to represent a date, a datetime or a time) into
# a Python datetime.datetime
# @param xldate The Excel number
# @param datemode 0: 1900-based, 1: 1904-based.
# @return a datetime.datetime object, to the nearest_second.
# <br>Special case: if 0.0 <= xldate < 1.0, it is assumed to represent a time;
# a datetime.time object will be returned.
# <br>Note: 1904-01-01 is not regarded as a valid date in the datemode 1 system; its "serial number"
# is zero.
#
# _XLDAYS_TOO_LARGE = (2958466, 2958466 - 1462) # This is equivalent to 10000-01-01
#
def xldate_as_datetime(xldate, datemode=0):
return openpyxl.utils.datetime.from_ISO8601(xldate)
# if datemode not in (0, 1):
# raise ValueError("invalid mode %s" % datemode)
# if xldate == 0.00:
# return datetime.time(0, 0, 0)
# if xldate < 0.00:
# raise ValueError("invalid date code %s" % xldate)
# xldays = int(xldate)
# frac = xldate - xldays
# seconds = int(round(frac * 86400.0))
# assert 0 <= seconds <= 86400
# if seconds == 86400:
# seconds = 0
# xldays += 1
# if xldays >= _XLDAYS_TOO_LARGE[datemode]:
# raise ValueError("date too large %s" % xldate)
#
# if xldays == 0:
# # second = seconds % 60; minutes = seconds // 60
# minutes, second = divmod(seconds, 60)
# # minute = minutes % 60; hour = minutes // 60
# hour, minute = divmod(minutes, 60)
# return datetime.time(hour, minute, second)
#
# if xldays < 61 and datemode == 0:
# raise ValueError("ambiguous date %s" % xldate)
#
# return datetime.datetime.fromordinal(
# xldays + 693594 + 1462 * datemode
# ) + datetime.timedelta(seconds=seconds)
class ScoExcelBook:
"""Permet la génération d'un classeur xlsx composé de plusieurs feuilles.
usage:
wb = ScoExcelBook()
ws0 = wb.create_sheet('sheet name 0')
ws1 = wb.create_sheet('sheet name 1')
...
steam = wb.generate()
"""
def __init__(self):
self.sheets = [] # list of sheets
def create_sheet(self, sheet_name="feuille", default_style=None):
"""Crée une nouvelle feuille dans ce classeur
sheet_name -- le nom de la feuille
default_style -- le style par défaut
"""
sheet = ScoExcelSheet(sheet_name, default_style)
self.sheets.append(sheet)
return sheet
def generate(self):
"""génération d'un stream binaire représentant la totalité du classeur.
retourne le flux
"""
wb = Workbook(write_only=True)
for sheet in self.sheets:
sheet.generate(self)
# construction d'un flux (https://openpyxl.readthedocs.io/en/stable/tutorial.html#saving-as-a-stream)
with NamedTemporaryFile() as tmp:
wb.save(tmp.name)
tmp.seek(0)
return tmp.read()
def excel_make_style(
bold=False,
italic=False,
color: COLORS = COLORS.BLACK,
bgcolor: COLORS = None,
halign=None,
valign=None,
format_number=None,
font_name="Arial",
size=10,
):
"""Contruit un style.
Les couleurs peuvent être spécfiées soit par une valeur de COLORS,
soit par une chaine argb (exple "FF00FF00" pour le vert)
color -- La couleur du texte
bgcolor -- la couleur de fond
halign -- alignement horizontal ("left", "right", "center")
valign -- alignement vertical ("top", "bottom", "center")
format_number -- formattage du contenu ("General", "@", ...)
font_name -- police
size -- taille de police
"""
style = {}
font = Font(name=font_name, bold=bold, italic=italic, color=color.value, size=size)
style["font"] = font
if bgcolor:
style["fill"] = PatternFill(fill_type="solid", fgColor=bgcolor.value)
if halign or valign:
al = Alignment()
if halign:
al.horizontal = {
"left": "left",
"right": "right",
"center": "center",
}[halign]
if valign:
al.vertical = {
"top": "top",
"bottom": "bottom",
"center": "center",
}[valign]
style["alignment"] = al
if format_number is None:
style["format_number"] = "General"
else:
style["format_number"] = format_number
return style
class ScoExcelSheet:
"""Représente une feuille qui peut être indépendante ou intégrée dans un SCoExcelBook.
En application des directives de la bibliothèque sur l'écriture optimisée, l'ordre des opérations
est imposé:
* instructions globales (largeur/maquage des colonnes et ligne, ...)
* construction et ajout des cellules et ligne selon le sens de lecture (occidental)
ligne de haut en bas et cellules de gauche à droite (i.e. A1, A2, .. B1, B2, ..)
* pour finit appel de la méthode de génération
"""
def __init__(self, sheet_name="feuille", default_style=None, wb=None):
"""Création de la feuille.
sheet_name -- le nom de la feuille
default_style -- le style par défaut des cellules
wb -- le WorkBook dans laquelle se trouve la feuille. Si wb est None (cas d'un classeur mono-feuille),
un workbook est crée et associé à cette feuille.
"""
self.sheet_name = sheet_name
self.rows = [] # list of list of cells
# self.cells_styles_lico = {} # { (li,co) : style }
# self.cells_styles_li = {} # { li : style }
# self.cells_styles_co = {} # { co : style }
if default_style is None:
default_style = excel_make_style()
self.default_style = default_style
self.wb = wb or Workbook(write_only=True) # Création de workbook si nécessaire
self.ws = self.wb.create_sheet(title=self.sheet_name)
self.column_dimensions = {}
def set_column_dimension_width(self, cle, value):
"""Détermine la largeur d'une colonne.
cle -- identifie la colonne ("A"n "B", ...)
value -- la dimension (unité : 7 pixels comme affiché dans Excel)
"""
self.ws.column_dimensions[cle].width = value
def set_column_dimension_hidden(self, cle, value):
"""Masque ou affiche une colonne.
cle -- identifie la colonne ("A"n "B", ...)
value -- boolean (vrai = colonne cachée)
"""
self.ws.column_dimensions[cle].hidden = value
def make_cell(self, value: any = None, style=None):
"""Construit une cellule.
value -- contenu de la cellule (texte ou numérique)
style -- style par défaut (dictionnaire cf. excel_make_style) de la feuille si non spécifié
"""
cell = WriteOnlyCell(self.ws, value or "")
# if style is not None and "fill" in style:
# toto()
if style is None:
style = self.default_style
if "font" in style:
cell.font = style["font"]
if "border" in style:
cell.border = style["border"]
if "number_format" in style:
cell.number_format = style["number_format"]
if "fill" in style:
cell.fill = style["fill"]
if "alignment" in style:
cell.alignment = style["alignment"]
return cell
def make_row(self, values: list, style=None):
return [self.make_cell(value, style) for value in values]
def append_single_cell_row(self, value: any, style=None):
"""construit une ligne composée d'une seule cellule et l'ajoute à la feuille.
mêmes paramètres que make_cell:
value -- contenu de la cellule (texte ou numérique)
style -- style par défaut de la feuille si non spécifié
"""
self.append_row([self.make_cell(value, style)])
def append_blank_row(self):
"""construit une ligne vide et l'ajoute à la feuille."""
self.append_row([None])
def append_row(self, row):
"""ajoute une ligne déjà construite à la feuille."""
self.rows.append(row)
# def set_style(self, style=None, li=None, co=None):
# if li is not None and co is not None:
# self.cells_styles_lico[(li, co)] = style
# elif li is None:
# self.cells_styles_li[li] = style
# elif co is None:
# self.cells_styles_co[co] = style
#
# def get_cell_style(self, li, co):
# """Get style for specified cell"""
# return (
# self.cells_styles_lico.get((li, co), None)
# or self.cells_styles_li.get(li, None)
# or self.cells_styles_co.get(co, None)
# or self.default_style
# )
def _generate_ws(self):
"""génére un flux décrivant la feuille.
Ce flux pourra ensuite être repris dans send_excel_file (classeur mono feille)
ou pour la génération d'un classeur multi-feuilles
"""
for col in self.column_dimensions.keys():
self.ws.column_dimensions[col] = self.column_dimensions[col]
for row in self.rows:
self.ws.append(row)
def generate_standalone(self):
"""génération d'un classeur mono-feuille"""
self._generate_ws()
# construction d'un flux (https://openpyxl.readthedocs.io/en/stable/tutorial.html#saving-as-a-stream)
with NamedTemporaryFile() as tmp:
self.wb.save(tmp.name)
tmp.seek(0)
return tmp.read()
def generate_embeded(self):
"""generation d'une feuille include dans un classeur multi-feuilles"""
self._generate_ws()
def gen_workbook(self, wb=None):
"""TODO: à remplacer"""
"""Generates and returns a workbook from stored data.
If wb, add a sheet (tab) to the existing workbook (in this case, returns None).
"""
if wb is None:
wb = Workbook() # Création du fichier
sauvegarde = True
else:
sauvegarde = False
ws0 = wb.add_sheet(self.sheet_name)
li = 0
for row in self.rows:
co = 0
for c in row:
# safety net: allow only str, int and float
# #py3 #sco8 A revoir lors de la ré-écriture de ce module
# XXX if type(c) not in (IntType, FloatType):
# c = str(c).decode(scu.SCO_ENCODING)
ws0.write(li, co, c, self.get_cell_style(li, co))
co += 1
li += 1
if sauvegarde:
return wb.savetostr()
else:
return None
def excel_simple_table(
titles=None, lines=None, sheet_name=b"feuille", titles_styles=None
):
"""Export simple type 'CSV': 1ere ligne en gras, le reste tel quel"""
ws = ScoExcelSheet(sheet_name)
if titles is None:
titles = []
if lines is None:
lines = [[]]
if titles_styles is None:
style = excel_make_style(bold=True)
titles_styles = [style] * len(titles)
# ligne de titres
ws.append_row(
[ws.make_cell(it, style) for (it, style) in zip(titles, titles_styles)]
)
default_style = excel_make_style()
text_style = excel_make_style(format_number="@")
for line in lines:
cells = []
for it in line:
# safety net: allow only str, int and float
# TODO Plus de type Long en Python 3 ?
# if isinstance(it, long): # XXX
# it = int(it) # assume all ScoDoc longs fits in int !
cell_style = default_style
if type(it) not in (int, float): # XXX A REVOIR
cell_style = text_style
cells.append(ws.make_cell(it, cell_style))
ws.append_row(cells)
return ws.generate_standalone()
def excel_feuille_saisie(e, titreannee, description, lines):
"""Genere feuille excel pour saisie des notes.
E: evaluation (dict)
lines: liste de tuples
(etudid, nom, prenom, etat, groupe, val, explanation)
"""
sheet_name = "Saisie notes"
ws = ScoExcelSheet(sheet_name)
# ajuste largeurs colonnes (unite inconnue, empirique)
ws.set_column_dimension_width("A", 11.0 / 7) # codes
# ws.set_column_dimension_hidden("A", True) # codes
ws.set_column_dimension_width("B", 164.00 / 7) # noms
ws.set_column_dimension_width("C", 109.0 / 7) # prenoms
ws.set_column_dimension_width("D", 164.0 / 7) # groupes
ws.set_column_dimension_width("E", 115.0 / 7) # notes
ws.set_column_dimension_width("F", 355.0 / 7) # remarques
# fontes
font_base = Font(name="Arial", size=12)
font_bold = Font(name="Arial", bold=True)
font_italic = Font(name="Arial", size=12, italic=True, color=COLORS.RED.value)
font_titre = Font(name="Arial", bold=True, size=14)
font_purple = Font(name="Arial", color=COLORS.PURPLE.value)
font_brown = Font(name="Arial", color=COLORS.BROWN.value)
font_blue = Font(name="Arial", size=9, color=COLORS.BLUE.value)
# bordures
side_thin = Side(border_style="thin", color=COLORS.BLACK.value)
border_top = Border(top=side_thin)
border_right = Border(right=side_thin)
# fonds
fill_light_yellow = PatternFill(
patternType="solid", fgColor=COLORS.LIGHT_YELLOW.value
)
# styles
style = {"font": font_base}
style_titres = {"font": font_titre}
style_expl = {"font": font_italic}
style_ro = { # cells read-only
"font": font_purple,
"border": border_right,
}
style_dem = {
"font": font_brown,
"border": border_top,
}
style_nom = { # style pour nom, prenom, groupe
"font": font_base,
"border": border_top,
}
style_notes = {
"font": font_bold,
"number_format": "General",
"fill": fill_light_yellow,
"border": border_top,
}
style_comment = {
"font": font_blue,
"border": border_top,
}
# ligne de titres
ws.append_single_cell_row(
"Feuille saisie note (à enregistrer au format excel)", style_titres
)
# lignes d'instructions
ws.append_single_cell_row(
"Saisir les notes dans la colonne E (cases jaunes)", style_expl
)
ws.append_single_cell_row("Ne pas modifier les cases en mauve !", style_expl)
# Nom du semestre
ws.append_single_cell_row(scu.unescape_html(titreannee), style_titres)
# description evaluation
ws.append_single_cell_row(scu.unescape_html(description), style_titres)
ws.append_single_cell_row(
"Evaluation du %s (coef. %g)" % (e["jour"], e["coefficient"]), style
)
# ligne blanche
ws.append_blank_row()
# code et titres colonnes
ws.append_row(
[
ws.make_cell("!%s" % e["evaluation_id"], style_ro),
ws.make_cell("Nom", style_titres),
ws.make_cell("Prénom", style_titres),
ws.make_cell("Groupe", style_titres),
ws.make_cell("Note sur %g" % e["note_max"], style_titres),
ws.make_cell("Remarque", style_titres),
]
)
# etudiants
for line in lines:
st = style_nom
if line[3] != "I":
st = style_dem
if line[3] == "D": # demissionnaire
s = "DEM"
else:
s = line[3] # etat autre
else:
s = line[4] # groupes TD/TP/...
try:
val = float(line[5])
except ValueError:
val = line[5]
ws.append_row(
[
ws.make_cell("!" + line[0], style_ro), # code
ws.make_cell(line[1], st),
ws.make_cell(line[2], st),
ws.make_cell(s, st),
ws.make_cell(val, style_notes), # note
ws.make_cell(line[6], style_comment), # comment
]
)
# explication en bas
ws.append_row([None, ws.make_cell("Code notes", style_titres)])
ws.append_row(
[
None,
ws.make_cell("ABS", style_expl),
ws.make_cell("absent (0)", style_expl),
]
)
ws.append_row(
[
None,
ws.make_cell("EXC", style_expl),
ws.make_cell("pas prise en compte", style_expl),
]
)
ws.append_row(
[
None,
ws.make_cell("ATT", style_expl),
ws.make_cell("en attente", style_expl),
]
)
ws.append_row(
[
None,
ws.make_cell("SUPR", style_expl),
ws.make_cell("pour supprimer note déjà entrée", style_expl),
]
)
ws.append_row(
[
None,
ws.make_cell("", style_expl),
ws.make_cell("cellule vide -> note non modifiée", style_expl),
]
)
return ws.generate_standalone()
def excel_bytes_to_list(bytes_content):
filelike = io.BytesIO(bytes_content)
return _excel_to_list(filelike)
def excel_file_to_list(filename):
return _excel_to_list(filename)
def _excel_to_list(filelike): # we may need 'encoding' argument ?
"""returns list of list
convert_to_string is a conversion function applied to all non-string values (ie numbers)
"""
try:
wb = load_workbook(filename=filelike, read_only=True, data_only=True)
except:
log("Excel_to_list: failure to import document")
open("/tmp/last_scodoc_import_failure" + scu.XLSX_SUFFIX, "wb").write(filelike)
raise ScoValueError(
"Fichier illisible: assurez-vous qu'il s'agit bien d'un document Excel !"
)
diag = [] # liste de chaines pour former message d'erreur
# n'utilise que la première feuille
if len(wb.get_sheet_names()) < 1:
diag.append("Aucune feuille trouvée dans le classeur !")
return diag, None
if len(wb.get_sheet_names()) > 1:
diag.append("Attention: n'utilise que la première feuille du classeur !")
# fill matrix
sheet_name = wb.get_sheet_names()[0]
ws = wb.get_sheet_by_name(sheet_name)
sheet_name = sheet_name.encode(scu.SCO_ENCODING, "backslashreplace")
values = {}
for row in ws.iter_rows():
for cell in row:
if cell.value is not None:
values[(cell.row - 1, cell.column - 1)] = str(cell.value)
if not values:
diag.append(
"Aucune valeur trouvée dans la feuille %s !"
% sheet_name.decode(scu.SCO_ENCODING)
)
return diag, None
indexes = list(values.keys())
# search numbers of rows and cols
rows = [x[0] for x in indexes]
cols = [x[1] for x in indexes]
nbcols = max(cols) + 1
nbrows = max(rows) + 1
m = []
for _ in range(nbrows):
m.append([""] * nbcols)
for row_idx, col_idx in indexes:
v = values[(row_idx, col_idx)]
# if isinstance(v, six.text_type):
# v = v.encode(scu.SCO_ENCODING, "backslashreplace")
# elif convert_to_string:
# v = convert_to_string(v)
m[row_idx][col_idx] = v
diag.append(
'Feuille "%s", %d lignes' % (sheet_name.decode(scu.SCO_ENCODING), len(m))
)
# diag.append(str(M))
#
return diag, m
def excel_feuille_listeappel(
sem,
groupname,
lines,
partitions=None,
with_codes=False,
with_paiement=False,
server_name=None,
):
"""generation feuille appel"""
if partitions is None:
partitions = []
formsemestre_id = sem["formsemestre_id"]
sheet_name = "Liste " + groupname
ws = ScoExcelSheet(sheet_name)
ws.set_column_dimension_width("A", 3)
ws.set_column_dimension_width("B", 35)
ws.set_column_dimension_width("C", 12)
font1 = Font(name="Arial", size=11)
font1i = Font(name="Arial", size=10, italic=True)
font1b = Font(name="Arial", size=11, bold=True)
side_thin = Side(border_style="thin", color=COLORS.BLACK.value)
border_tbl = Border(top=side_thin, bottom=side_thin, left=side_thin)
border_tblr = Border(
top=side_thin, bottom=side_thin, left=side_thin, right=side_thin
)
style1i = {
"font": font1i,
}
style1b = {
"font": font1,
"border": border_tbl,
}
style2 = {
"font": Font(name="Arial", size=14),
}
style2b = {
"font": font1i,
"border": border_tblr,
}
style2t3 = {
"border": border_tblr,
}
style2t3bold = {
"font": font1b,
"border": border_tblr,
}
style3 = {
"font": Font(name="Arial", bold=True, size=14),
}
nb_weeks = 4 # nombre de colonnes pour remplir absences
# ligne 1
title = "%s %s (%s - %s)" % (
sco_preferences.get_preference("DeptName", formsemestre_id),
notesdb.unquote(sem["titre_num"]),
sem["date_debut"],
sem["date_fin"],
)
ws.append_row([None, ws.make_cell(title, style2)])
# ligne 2
ws.append_row([None, ws.make_cell("Discipline :", style2)])
# ligne 3
cell_2 = ws.make_cell("Enseignant :", style2)
cell_6 = ws.make_cell(("Groupe %s" % groupname), style3)
ws.append_row([None, cell_2, None, None, None, None, cell_6])
# ligne 4: Avertissement pour ne pas confondre avec listes notes
cell_2 = ws.make_cell(
"Ne pas utiliser cette feuille pour saisir les notes !", style1i
)
ws.append_row([None, None, cell_2])
ws.append_blank_row()
ws.append_blank_row()
# ligne 7: Entête (contruction dans une liste cells)
cell_2 = ws.make_cell("Nom", style3)
cells = [None, cell_2]
for partition in partitions:
cells.append(ws.make_cell(partition["partition_name"], style3))
if with_codes:
cells.append(ws.make_cell("etudid", style3))
cells.append(ws.make_cell("code_nip", style3))
cells.append(ws.make_cell("code_ine", style3))
for i in range(nb_weeks):
cells.append(ws.make_cell("", style2b))
ws.append_row(cells)
n = 0
# pour chaque étudiant
for t in lines:
n += 1
nomprenom = (
t["civilite_str"] + " " + t["nom"] + " " + t["prenom"].lower().capitalize()
)
style_nom = style2t3
if with_paiement:
paie = t.get("paiementinscription", None)
if paie is None:
nomprenom += " (inscription ?)"
style_nom = style2t3bold
elif not paie:
nomprenom += " (non paiement)"
style_nom = style2t3bold
cell_1 = ws.make_cell(n, style1b)
cell_2 = ws.make_cell(nomprenom, style_nom)
cells = [cell_1, cell_2]
for partition in partitions:
if partition["partition_name"]:
cells.append(
ws.make_cell(t.get(partition["partition_id"], ""), style2t3)
)
if with_codes:
cells.append(ws.make_cell(t["etudid"], style2t3))
code_nip = t.get("code_nip", "")
cells.append(ws.make_cell(code_nip, style2t3))
code_ine = t.get("code_ine", "")
cells.append(ws.make_cell(code_ine, style2t3))
cells.append(ws.make_cell(t.get("etath", ""), style2b))
for i in range(1, nb_weeks):
cells.append(ws.make_cell(style=style2t3))
ws.append_row(cells)
ws.append_blank_row()
# bas de page (date, serveur)
dt = time.strftime("%d/%m/%Y à %Hh%M")
if server_name:
dt += " sur " + server_name
cell_2 = ws.make_cell(("Liste éditée le " + dt), style1i)
ws.append_row([None, cell_2])
return ws.generate_standalone()
Reference in New Issue View Git Blame Copy Permalink