def __init__(self, p_percorso_tema: str):
"""
Inizializza la classe passandogli subito i parametri generali
da utilizzare per creare le pagine (roba come il nome del sito,
il disclaimer da scrivere in ogni piè di pagina, ...)
Args:
p_percorso_tema (str):
Percorso alla cartella che contiene i layout e gli asset
per renderizzare le pagine e gli articoli con il tema
Returns:
None
"""
self._preferenze_sito = Preferenze()
# Carica le eventuali preferenze del tema
percorso_config = os.path.join(p_percorso_tema, "_config.yml")
try:
# Carica (o perlomeno tenta) il file delle preferenze _config.yml
self._preferenze_tema = Preferenze(percorso_config)
except FilePreferenzeNonTrovato:
# Non esiste un file _config.yml con le preferenze del tema
# Usa quelle di default
self._preferenze_tema = Preferenze()
# Chiama in causa Jinja2 e gli spiega da quale
# cartella dovrà tirarsi su i template/layout da utilizzare
# per creare le pagine HTML
self.jinja2 = Environment(
loader=FileSystemLoader(p_percorso_tema),
trim_blocks=True)
class Pagina:
"""
Questa classe gestisce una pagina
"""
def __init__(self, p_file):
self.meta = Preferenze()
self.contenuto = ""
self.importa(p_file)
def importa(self, p_file):
with open(p_file) as f:
leggi_yaml = False
parte_yaml = ""
parte_testo = ""
for riga in f:
if riga[:3] == "---" and riga[-1:] == "\n":
leggi_yaml = not leggi_yaml
else:
if leggi_yaml:
parte_yaml += riga
else:
parte_testo += riga
f.close()
self.meta.importa_da_testo(parte_yaml)
self.contenuto = markdown2.markdown(parte_testo)
try:
# Se l'articolo / pagina ha una proprietà "title" da usare..
titolo = self.meta.title
self.meta.url = self.decidi_url(titolo)
except TagNonTrovato:
# Altrimenti come nome usa quello del file senza estensione
nome, estensione = os.path.splitext(os.path.basename(p_file))
self.meta.url = self.decidi_url(nome)
@staticmethod
def decidi_url(p_nome):
# Rimuove tutte le accentate e le sostituisce con caratteri ASCII
nfkd_form = unicodedata.normalize('NFKD', p_nome)
temp = u"".join([c for c in nfkd_form if not unicodedata.combining(c)])
# Sostituisce gli spazi e altri caratteri con delle lineette
temp = temp.lower().replace(chr(32), "-") \
.replace(".", "-").replace(",", "-") \
.replace(";", "-").replace(":", "-") \
.replace("'", "-").replace(chr(34), "-")
# Elimina i casi in cui ci sono due o tre lineette di seguito
temp = temp.replace("---", "-").replace("--", "-")
# Restituisce la stringa modificata
return temp
def __str__(self) -> str:
temp = "FILE: {0}\n".format(self.url)
temp += str(self.meta)
temp += self.meta.content
return temp
def render(self,
p_pagina: Pagina,
p_layout_default: str = "default") -> str:
"""
Crea un file HTML a partire da un template/layout
indicato ed utilizzando i parametri globali e
quelli passati dall'utente.
Args:
p_pagina (Pagine):
Un'istanza della classe Pagina che conterrà la pagina da convertire
p_layout_default (String):
Se non viene indicato nelle preferenze di una pagina,
per il rendering utilizza questo layout
Returns (String):
Una stringa contenente il codice HTML della pagina
appena costruita dal metodo
"""
# Decide quale layout deve utilizzare
# per fare il rendering della pagina
try:
# La pagina in questione ha nella parte YAML
# un parametro "layout" che specifica come
# l'utente vuole renderizzarla ?
layout = p_pagina.meta.layout
except TagNonTrovato:
# No. Allora decide il programma per l'utente.
layout = p_layout_default
# PATCH DA RIMUOVERE
layout = "default"
# Fa caricare il template in memoria a Jinja2
try:
template = self.jinja2.get_template(layout + ".html")
except TemplateNotFound:
template = self.jinja2.get_template(p_layout_default + ".html")
# Prepara il dizionario con i parametri da passare a Jinja2,
# unendo quelli globali del sito a quelli del tema ed
# aggiunge quelli della pagina che sta renderizzando
preferenze = Preferenze()
preferenze["site"] = self._preferenze_sito.esporta()
preferenze["theme"] = self._preferenze_tema.esporta()
preferenze["page"] = p_pagina.meta.esporta()
preferenze["page"]["content"] = p_pagina.contenuto
preferenze["content"] = preferenze["page"]["content"]
# Renderizza la pagina e la restituisce
return template.render(preferenze.esporta())
def render(self, p_pagina: Pagina, p_layout_default: str = "default") -> str:
"""
Crea un file HTML a partire da un template/layout
indicato ed utilizzando i parametri globali e
quelli passati dall'utente.
Args:
p_pagina (Pagine):
Un'istanza della classe Pagina che conterrà la pagina da convertire
p_layout_default (String):
Se non viene indicato nelle preferenze di una pagina,
per il rendering utilizza questo layout
Returns (String):
Una stringa contenente il codice HTML della pagina
appena costruita dal metodo
"""
# Decide quale layout deve utilizzare
# per fare il rendering della pagina
try:
# La pagina in questione ha nella parte YAML
# un parametro "layout" che specifica come
# l'utente vuole renderizzarla ?
layout = p_pagina.meta.layout
except TagNonTrovato:
# No. Allora decide il programma per l'utente.
layout = p_layout_default
# PATCH DA RIMUOVERE
layout = "default"
# Fa caricare il template in memoria a Jinja2
try:
template = self.jinja2.get_template(layout + ".html")
except TemplateNotFound:
template = self.jinja2.get_template(p_layout_default + ".html")
# Prepara il dizionario con i parametri da passare a Jinja2,
# unendo quelli globali del sito a quelli del tema ed
# aggiunge quelli della pagina che sta renderizzando
preferenze = Preferenze()
preferenze["site"] = self._preferenze_sito.esporta()
preferenze["theme"] = self._preferenze_tema.esporta()
preferenze["page"] = p_pagina.meta.esporta()
preferenze["page"]["content"] = p_pagina.contenuto
preferenze["content"] = preferenze["page"]["content"]
# Renderizza la pagina e la restituisce
return template.render(preferenze.esporta())
def __init__(self, p_percorso):
self.basedir = p_percorso
# Carica le preferenze del sito
preferenze = Preferenze(os.path.join(self.basedir, "_config.yml"))
# Carica le pagine da convertire
self.lista = Pagine(os.path.join(self.basedir, "_pages"))
# Carica il tema da utilizzare
try:
nome_tema = preferenze.theme
except TagNonTrovato:
nome_tema = "default"
percorso_cartella_temi = os.path.join(self.basedir, "_themes")
if not os.path.exists(percorso_cartella_temi):
os.mkdir(percorso_cartella_temi)
percorso_tema = os.path.join(percorso_cartella_temi, nome_tema)
if not os.path.exists(percorso_tema):
os.mkdir(percorso_tema)
self.tema = Tema(percorso_tema)
self.tema.set_preferenze_sito(preferenze)
def _carica_preferenze(self):
"""
Verifica se esiste un file delle preferenze nella cartella indicata
Se esiste, lo carica
Returns:
None
"""
file_preferenze = os.path.join(self._percorso, "_config.yml")
if os.path.exists(file_preferenze):
self._preferenze = Preferenze(file_preferenze)
def __init__(self, p_percorso_tema: str):
"""
Inizializza la classe passandogli subito i parametri generali
da utilizzare per creare le pagine (roba come il nome del sito,
il disclaimer da scrivere in ogni piè di pagina, ...)
Args:
p_percorso_tema (str):
Percorso alla cartella che contiene i layout e gli asset
per renderizzare le pagine e gli articoli con il tema
Returns:
None
"""
self._preferenze_sito = Preferenze()
# Carica le eventuali preferenze del tema
percorso_config = os.path.join(p_percorso_tema, "_config.yml")
try:
# Carica (o perlomeno tenta) il file delle preferenze _config.yml
self._preferenze_tema = Preferenze(percorso_config)
except FilePreferenzeNonTrovato:
# Non esiste un file _config.yml con le preferenze del tema
# Usa quelle di default
self._preferenze_tema = Preferenze()
# Chiama in causa Jinja2 e gli spiega da quale
# cartella dovrà tirarsi su i template/layout da utilizzare
# per creare le pagine HTML
self.jinja2 = Environment(loader=FileSystemLoader(p_percorso_tema),
trim_blocks=True)
def __init__(self, p_percorso: str, p_crea_se_inesistente=True):
"""
Costruttore della classe
Args:
p_percorso: Percorso alla cartella contenente le pagine (_pages)
"""
self._percorso = p_percorso
# Controlla se nel caso deve creare la cartella per le pagine
if p_crea_se_inesistente:
# Crea la cartella delle pagine se non esiste già
if not os.path.exists(self._percorso):
os.mkdir(self._percorso)
self._preferenze = Preferenze()
self._elenco = []
self._carica_preferenze()
self._carica_tutti()
class Tema:
"""
Questa classe fa da wrapper a Jinja2 e consente di
creare dei file HTML a partire da un template in formato HTML e dei
parametri passati sotto forma di dizionario/oggetto
"""
def __init__(self, p_percorso_tema: str):
"""
Inizializza la classe passandogli subito i parametri generali
da utilizzare per creare le pagine (roba come il nome del sito,
il disclaimer da scrivere in ogni piè di pagina, ...)
Args:
p_percorso_tema (str):
Percorso alla cartella che contiene i layout e gli asset
per renderizzare le pagine e gli articoli con il tema
Returns:
None
"""
self._preferenze_sito = Preferenze()
# Carica le eventuali preferenze del tema
percorso_config = os.path.join(p_percorso_tema, "_config.yml")
try:
# Carica (o perlomeno tenta) il file delle preferenze _config.yml
self._preferenze_tema = Preferenze(percorso_config)
except FilePreferenzeNonTrovato:
# Non esiste un file _config.yml con le preferenze del tema
# Usa quelle di default
self._preferenze_tema = Preferenze()
# Chiama in causa Jinja2 e gli spiega da quale
# cartella dovrà tirarsi su i template/layout da utilizzare
# per creare le pagine HTML
self.jinja2 = Environment(loader=FileSystemLoader(p_percorso_tema),
trim_blocks=True)
def set_preferenze_sito(self, p_preferenze):
self._preferenze_sito = p_preferenze
def render(self,
p_pagina: Pagina,
p_layout_default: str = "default") -> str:
"""
Crea un file HTML a partire da un template/layout
indicato ed utilizzando i parametri globali e
quelli passati dall'utente.
Args:
p_pagina (Pagine):
Un'istanza della classe Pagina che conterrà la pagina da convertire
p_layout_default (String):
Se non viene indicato nelle preferenze di una pagina,
per il rendering utilizza questo layout
Returns (String):
Una stringa contenente il codice HTML della pagina
appena costruita dal metodo
"""
# Decide quale layout deve utilizzare
# per fare il rendering della pagina
try:
# La pagina in questione ha nella parte YAML
# un parametro "layout" che specifica come
# l'utente vuole renderizzarla ?
layout = p_pagina.meta.layout
except TagNonTrovato:
# No. Allora decide il programma per l'utente.
layout = p_layout_default
# PATCH DA RIMUOVERE
layout = "default"
# Fa caricare il template in memoria a Jinja2
try:
template = self.jinja2.get_template(layout + ".html")
except TemplateNotFound:
template = self.jinja2.get_template(p_layout_default + ".html")
# Prepara il dizionario con i parametri da passare a Jinja2,
# unendo quelli globali del sito a quelli del tema ed
# aggiunge quelli della pagina che sta renderizzando
preferenze = Preferenze()
preferenze["site"] = self._preferenze_sito.esporta()
preferenze["theme"] = self._preferenze_tema.esporta()
preferenze["page"] = p_pagina.meta.esporta()
preferenze["page"]["content"] = p_pagina.contenuto
preferenze["content"] = preferenze["page"]["content"]
# Renderizza la pagina e la restituisce
return template.render(preferenze.esporta())
def __init__(self, p_file):
self.meta = Preferenze()
self.contenuto = ""
self.importa(p_file)
class Tema:
"""
Questa classe fa da wrapper a Jinja2 e consente di
creare dei file HTML a partire da un template in formato HTML e dei
parametri passati sotto forma di dizionario/oggetto
"""
def __init__(self, p_percorso_tema: str):
"""
Inizializza la classe passandogli subito i parametri generali
da utilizzare per creare le pagine (roba come il nome del sito,
il disclaimer da scrivere in ogni piè di pagina, ...)
Args:
p_percorso_tema (str):
Percorso alla cartella che contiene i layout e gli asset
per renderizzare le pagine e gli articoli con il tema
Returns:
None
"""
self._preferenze_sito = Preferenze()
# Carica le eventuali preferenze del tema
percorso_config = os.path.join(p_percorso_tema, "_config.yml")
try:
# Carica (o perlomeno tenta) il file delle preferenze _config.yml
self._preferenze_tema = Preferenze(percorso_config)
except FilePreferenzeNonTrovato:
# Non esiste un file _config.yml con le preferenze del tema
# Usa quelle di default
self._preferenze_tema = Preferenze()
# Chiama in causa Jinja2 e gli spiega da quale
# cartella dovrà tirarsi su i template/layout da utilizzare
# per creare le pagine HTML
self.jinja2 = Environment(
loader=FileSystemLoader(p_percorso_tema),
trim_blocks=True)
def set_preferenze_sito(self, p_preferenze):
self._preferenze_sito = p_preferenze
def render(self, p_pagina: Pagina, p_layout_default: str = "default") -> str:
"""
Crea un file HTML a partire da un template/layout
indicato ed utilizzando i parametri globali e
quelli passati dall'utente.
Args:
p_pagina (Pagine):
Un'istanza della classe Pagina che conterrà la pagina da convertire
p_layout_default (String):
Se non viene indicato nelle preferenze di una pagina,
per il rendering utilizza questo layout
Returns (String):
Una stringa contenente il codice HTML della pagina
appena costruita dal metodo
"""
# Decide quale layout deve utilizzare
# per fare il rendering della pagina
try:
# La pagina in questione ha nella parte YAML
# un parametro "layout" che specifica come
# l'utente vuole renderizzarla ?
layout = p_pagina.meta.layout
except TagNonTrovato:
# No. Allora decide il programma per l'utente.
layout = p_layout_default
# PATCH DA RIMUOVERE
layout = "default"
# Fa caricare il template in memoria a Jinja2
try:
template = self.jinja2.get_template(layout + ".html")
except TemplateNotFound:
template = self.jinja2.get_template(p_layout_default + ".html")
# Prepara il dizionario con i parametri da passare a Jinja2,
# unendo quelli globali del sito a quelli del tema ed
# aggiunge quelli della pagina che sta renderizzando
preferenze = Preferenze()
preferenze["site"] = self._preferenze_sito.esporta()
preferenze["theme"] = self._preferenze_tema.esporta()
preferenze["page"] = p_pagina.meta.esporta()
preferenze["page"]["content"] = p_pagina.contenuto
preferenze["content"] = preferenze["page"]["content"]
# Renderizza la pagina e la restituisce
return template.render(preferenze.esporta())