sgelt 4.8.1__py3-none-any.whl

sgelt/__init__.py

@@ -0,0 +1,11 @@
+"""Set logging, locale and package_dir"""
+
+from pathlib import Path
+import locale
+from .__version__ import __version__
+
+__all__ = ['__version__', 'package_dir']
+
+locale.setlocale(locale.LC_TIME, 'fr_FR.UTF-8')
+
+package_dir = Path(__file__).parent

sgelt/__main__.py

@@ -0,0 +1,6 @@
+"""Enable to run with `python -m sgelt`"""
+
+from .main import main
+
+if __name__ == '__main__':
+    main()

sgelt/__version__.py

@@ -0,0 +1 @@
+__version__ = '4.8.1'

sgelt/calendar.py

@@ -0,0 +1,105 @@
+"""
+A module to export iCalendar events
+"""
+
+from icalendar import Calendar, Event, vText
+import logging
+from pathlib import Path
+import pytz
+import random
+import re
+import uuid
+import urllib.parse
+
+from sgelt.utils import slugify
+
+log = logging.getLogger(__name__)
+
+rd = random.Random()
+rd.seed(0)
+
+
+def build_calendar(prodid: str, ical_events: list) -> str:
+    """
+    Return a string containing the iCalendar events
+    """
+
+    cal = Calendar()
+    cal.add('prodid', prodid)
+    cal.add('version', '2.0')
+
+    tz = pytz.timezone('Europe/Paris')
+
+    for ical_event in ical_events:
+        event = Event()
+        event.add('summary', ical_event['summary'])
+        event.add('dtstart', tz.localize(ical_event['dtstart']).astimezone(tz))
+        event.add('dtend', tz.localize(ical_event['dtend']).astimezone(tz))
+        event.add('dtstamp', ical_event['dtstamp'])
+        try:
+            event['uid'] = ical_event['uuid']
+        except KeyError:
+            event['uid'] = str(uuid.UUID(int=rd.getrandbits(128)))
+        try:
+            event['location'] = vText(ical_event['location'])
+        except KeyError:
+            pass
+        try:
+            event['description'] = vText(ical_event['description'])
+        except KeyError:
+            pass
+        try:
+            # Encode URL for Apple Calendar
+            event['url'] = vText(urllib.parse.quote(ical_event['url'],
+                                                    safe='/:'))
+        except KeyError:
+            pass
+        event.add('priority', 5)
+        cal.add_component(event)
+
+    return cal.to_ical().decode('UTF-8')
+
+
+def merge_calendars(prodid: str, sem_calendar_paths: list,
+                    event_types: set) -> str:
+    """
+    Read a list of seminars iCalendar files and merge them into
+    a single iCalendar file
+    """
+    cal = Calendar()
+    cal.add('prodid', prodid)
+    cal.add('version', '2.0')
+
+    for calendar_path in sorted(sem_calendar_paths):
+        with open(calendar_path) as f:
+            sem_cal = Calendar.from_ical(f.read())
+        # Merge only seminars and Colloquium
+        pattern = r"^-\/\/.*\/\/((" + "|".join(event_types) + r") .*)\/\/.*$"
+        m = re.match(pattern, sem_cal['prodid'])
+        if m:
+            summary_prefix = m.group(1)
+            for event in sem_cal.walk(name='VEVENT'):
+                # Prepend seminar title to event summary
+                event['summary'] = f"{summary_prefix} - {event.get('summary')}"
+                cal.add_component(event)
+
+    return cal.to_ical().decode('UTF-8')
+
+
+def write_calendar_file(filename: str, conf,
+                        ical_content: str) -> str:
+    """
+    Write calendar content to an .ics file and return encoded url
+    """
+    ical_filepath = 'cal' / Path(slugify(filename)).with_suffix('.ics')
+    ical_outpath = conf.output_path / ical_filepath
+    log.debug(f"Export ical file to {ical_outpath}")
+    # Create parent directory if not exists
+    ical_outpath.parent.mkdir(exist_ok=True, parents=True)
+    ical_outpath.write_text(ical_content)
+    if 'url' in conf.site:
+        ical_url = \
+            f"{conf.site['url']}/{ical_filepath}"
+    else:
+        ical_url = ical_outpath.as_posix()
+    return urllib.parse.quote(ical_url, safe='/:')

sgelt/config.py

@@ -0,0 +1,179 @@
+"""Define site configuration class and instantiate in a conf object"""
+
+from datetime import date, datetime
+import jinja2
+import logging
+from pathlib import Path
+import yaml
+
+from . import filters, package_dir, __version__
+
+log = logging.getLogger(__name__)
+
+
+class Config:
+    """A class to store site configuration"""
+
+    # Default config dict that may be overriden by user values
+    def_conf = dict(
+        default_theme_path=package_dir / 'theme',
+        theme_path=None,
+        output_path='output',
+        content_path='content',
+        config_path='config.yml',
+        static_payload=('css', 'js', 'img'),
+        json_agenda_path='agenda_mysql.json',
+        json_teams_path='teams.json',
+        search_index=True
+    )
+
+    def __init__(self, args=None, config_path=None):
+        """Set class attributes from default"""
+        self.args = args
+        conf = self.def_conf.copy()
+        self._set_attributes(conf)
+        # Update config.yml default path
+        if config_path is not None:
+            self.update(config_path=config_path)
+        else:
+            try:
+                self.update(config_path=self.args.config_path)
+            except AttributeError:
+                pass
+        self.site = None
+
+    def save_args(self) -> dict:
+        """Return a dict of config.__init__() arguments"""
+        return {'args': self.args, 'config_path': self.config_path}
+
+    def update(self, **kwargs):
+        """Update object attributes from names args"""
+        conf = vars(self)  # get attributes as dict
+        # Update conf dict with init args if key exists
+        for k, v in kwargs.items():
+            if k in self.def_conf:
+                conf[k] = v
+            else:
+                log.warning(f"Cannot update conf dict with unknown key: {k}")
+        self._set_attributes(conf)
+
+    def load(self):
+        """Parse YAML config file and override with CLI args"""
+
+        # Read config.yml file
+        try:
+            with open(self.config_path) as f:
+                file_conf = yaml.safe_load(f)
+        except FileNotFoundError as e:
+            log.error(e)
+            log.debug(self)
+            import sys
+            sys.exit(1)
+
+        # site dict becomes .site attribute
+        self.site = file_conf.pop('site')
+
+        # Convert path/to/file.md -> path/to/file.html
+        for dropdown_items in self.site['nav_items'].values():
+            try:
+                for dropdown_name, filename in dropdown_items.items():
+                    filepath = Path(filename)
+                    # Convert markdown paths to html paths
+                    if filepath.suffix == '.md':
+                        dropdown_items[dropdown_name] = filepath.with_suffix(
+                            '.html').as_posix()
+            except AttributeError:
+                # dropdown_items is not an actual dropdown dict
+                pass
+
+        if 'today' in self.site:
+            # Convert today as date if exists
+            if type(self.site['today']) is not date:
+                self.site['today'] = self.site['today'].date()
+        else:
+            # Use today date
+            self.site['today'] = date.today()
+
+        # update other attributes (same as in def_conf)
+        self.update(**file_conf)
+
+        # Override with CLI args
+        args = self.args
+        if args is not None:
+            if args.json_agenda:
+                self.update(json_agenda_path=args.json_agenda)
+            if args.json_teams:
+                self.update(json_teams_path=args.json_teams)
+            if args.content:
+                self.update(content_path=args.content)
+            if args.output:
+                self.update(output_path=args.output)
+            if not args.search_index:
+                self.update(search_index=False)
+
+    def _set_attributes(self, conf: dict):
+        """From conf dict and default values, set class attributes"""
+        for k, v in conf.items():
+            if k != 'env':
+                if isinstance(v, list) or isinstance(v, tuple):
+                    setattr(self, k, [Path(item) for item in v])
+                elif isinstance(v, dict) or isinstance(v, type(None)):
+                    setattr(self, k, v)
+                elif isinstance(v, type(None)):
+                    pass
+                else:
+                    try:
+                        setattr(self, k, Path(v))
+                    except TypeError:
+                        setattr(self, k, v)
+
+        self.templates_paths = [self.default_theme_path / Path('templates')]
+        try:
+            if conf['theme_path'] and conf['theme_path'].is_relative_to(
+                    self.config_path.parent):
+                conf_theme_path = conf['theme_path']
+            else:
+                conf_theme_path = self.config_path.parent / conf['theme_path']
+            user_template_path = conf_theme_path / 'templates'
+            if user_template_path.exists():  # Add override template dir
+                self.templates_paths.append(user_template_path)
+        except TypeError:  # self.theme_path is None thus skip
+            pass
+        self.env = jinja2.Environment(
+            loader=jinja2.FileSystemLoader(self.templates_paths)
+        )
+
+        # Add filters
+        self.env.filters['homepage'] = filters.homepage
+        self.env.filters['agenda'] = filters.agenda
+        self.env.filters['event_date_time'] = filters.event_date_time
+        self.env.filters['categ_to_target'] = filters.categ_to_target
+        self.env.filters['url'] = filters.url
+        self.env.filters['external_url'] = filters.external_url
+        self.env.filters['event_selector'] = filters.event_selector
+        self.env.filters['sort_by_date'] = filters.sort_by_date
+        self.env.filters['homepage_news'] = filters.homepage_news
+        self.env.filters['news_page'] = filters.news_page
+        self.env.filters['dropdown_items'] = filters.dropdown_items
+        self.env.filters['real_teams'] = filters.real_teams
+        self.env.filters['teams'] = filters.teams
+        self.env.filters['organizing_teams'] = filters.organizing_teams
+
+        # Global variables
+        self.env.globals['datetime_min'] = datetime.min
+        self.env.globals['sgelt_version'] = __version__
+
+    def __repr__(self):
+        def _format(k, v):
+            if isinstance(v, list):
+                return "{}:\n{}".format(k, '\n'.join((f"    - {item}"
+                                                      for item in v)))
+            elif isinstance(v, dict):
+                import textwrap
+                return f"""\
+{k}:\n{textwrap.indent(yaml.dump(v, allow_unicode=True), 2 * ' ')}"""
+            else:
+                return f"{k}: {v}"
+        return '\n'.join((_format(k, v)
+                          for k, v in vars(self).items()
+                          if not isinstance(v, jinja2.Environment)))

sgelt/data.py

@@ -0,0 +1,42 @@
+"""
+A module to store agenda, news, events and teams data
+To be populated and modified by sgelt module
+"""
+
+from .utils import read_data
+
+
+class Data:
+    """A class to store site data"""
+
+    def __init__(self, conf):
+        """Initialize with configuration object and empty data"""
+
+        self.conf = conf  # a configuration object
+        # read from agenda.json
+        self.conferences = []
+        self.defenses = []
+        self.seminars = []
+
+        self.teams = {}  # read from teams.json
+
+        self.news = []  # will be populated by registering news
+        self.libnews = []  # will be populated by registering libnews
+        self.events = []  # will be populated by registering events
+
+    def read_files(self):
+        """Read data from json files"""
+
+        # Read agenda data from json file
+        agenda = read_data(self.conf.json_agenda_path)
+        self.conferences = agenda['conferences']
+        self.defenses = agenda['defenses']
+        self.seminars = agenda['seminars']
+
+        # Read team data from json file
+        self.teams = read_data(self.conf.json_teams_path)
+
+    def __repr__(self):
+        from pprint import pformat
+        return '\n'.join((f"{k}: {pformat(v)}"
+                          for k, v in vars(self).items()))

sgelt/filters.py

@@ -0,0 +1,282 @@
+import types
+from datetime import timedelta
+import jinja2
+
+from .utils import slugify
+
+
+def exclude_events(events):
+    """Exclude events whose speaker is TBA"""
+    for event in events:
+        try:
+            speaker = event['speaker']
+            if 'tba' not in speaker.lower().split():
+                yield event
+        except KeyError:
+            yield event
+
+
+def filter_titles(events):
+    """If event title is in to_filter, modify it to 'À venir'"""
+    title_filter = 'tba', 'à venir', 'à confirmer'
+    for event in events:
+        if event['title'].lower() in title_filter:
+            event['title'] = 'À venir'
+        yield event
+
+
+def sort_by_date(events, reverse=False) -> list:
+    """Revert events sort by date"""
+    event_list = list(events) if isinstance(
+        events, types.GeneratorType) else events
+    return sorted(event_list, key=lambda e: e['date'], reverse=reverse)
+
+
+@jinja2.pass_context
+def homepage(context, events) -> list:
+    """
+    - exclude TBA authors
+    - filter TBA titles
+    - (reverse) sort by date
+    - keep only 6 first events
+    """
+    site = context['site']
+    selected_events = exclude_events(events)
+    filtered_title_events = filter_titles(selected_events)
+    sorted_events = sort_by_date(filtered_title_events)
+    next_events = [e for e in sorted_events
+                   if e.get('end', e['date']).date() >= site['today']]
+    return next_events[:6]
+
+
+@jinja2.pass_context
+def homepage_news(context, site_news):
+    """
+    - keep only recent news
+    - (reverse) sort by date
+    """
+    site = context['site']
+    selected_news = (news for news in site_news if recent_news(news, site))
+    return sort_by_date(selected_news, reverse=True)[:5]
+
+
+@jinja2.pass_context
+def agenda(context, events):
+    """
+    - keep same category
+    - keep same year
+    - exclude TBA authors
+    - filter TBA titles
+    - (reverse) sort by date
+    """
+    page = context['page']
+    site = context['site']
+    if page.category:
+        category_selection = (
+            event for event in events if event['category'] == page.category)
+    else:
+        category_selection = (event for event in events if event['category'])
+
+    if page.name:
+        name_selection = (
+            event for event in category_selection
+            if page_name(event, site) == page.name
+        )
+    else:
+        name_selection = category_selection
+
+    author_selection = exclude_events(name_selection)
+    filter_titles_events = filter_titles(author_selection)
+    sorted_events = sort_by_date(filter_titles_events)
+    return sorted_events
+
+
+def event_date_time(event, weekday=False, sep=':') -> str:
+    """Return event date(s) (and time)"""
+
+    start = event['date']
+    try:
+        end = event['end']
+        if end != start:
+            if end.month == start.month:
+                return f"Du {start.day} au {end.day} {end.strftime('%B %Y')}"
+            else:
+                return (f"Du {start.day} {start.strftime('%B')} au {end.day} "
+                        f"{end.strftime('%B %Y')}")
+        else:
+            return f"""{start.strftime(
+                f"{'%A ' if weekday else ''}%-d %B %Y").capitalize()}"""
+
+    except KeyError:
+        date_time = start.strftime(
+            f"{'%A ' if weekday else ''}%-d %B %Y").capitalize()
+        if start.strftime("%H:%M") != '00:00':
+            format = f"%H{sep}%M"
+            date_time += f" - {start.strftime(format)}"
+        return date_time
+
+
+def categ_to_target(event):
+    """Return the target corresponding to event category"""
+    category = event['category']
+    if category == 'groupe de travail':
+        return "groupes-de-travail"
+    else:
+        return f"{slugify(category)}s"
+
+
+@jinja2.pass_context
+def url(context: dict, value: str) -> str:
+    """Return the relative url"""
+    if value.startswith(('http://', 'https://', '#')):
+        return value
+    else:
+        return context['page'].path_depth * '../' + value
+
+
+def external_url(value: str) -> str:
+    """Add attributes to external URLs a tags"""
+    if value.startswith(('http://', 'https://')):
+        return '\
+referrerpolicy="no-referrer" rel="noopener noreferrer" target="_blank"'
+    else:
+        return ''
+
+
+def page_name(event, site: dict):
+    """
+    Return the page name that event belongs to:
+    "À venir", "2020", "2019", etc.
+    """
+    event_date = event['date'].date()
+    return "À venir" if event_date >= site['today'] else event_date.year
+
+
+def event_selector(event, page):
+    """Return true if event should be display in page"""
+    site = page.conf.site
+    return (not page.paginator
+            or page.name == page_name(event, site))
+
+
+def recent_news(news: dict, site: dict) -> bool:
+    """Return True if news is less than 180 days ago"""
+    try:
+        date = news['date'].date()
+    except AttributeError:
+        date = news['date']
+    return date >= site['today'] - timedelta(days=180)
+
+
+def news_page_name(news, site: dict):
+    """
+    Return the page name that event belongs to:
+    "Récentes", "2020", "2019", etc.
+    """
+    # Handle both datetime and date objects
+    try:
+        year = news['date'].date().year
+    except AttributeError:
+        year = news['date'].year
+    return "Récentes" if recent_news(news, site) else year
+
+
+def news_selector(news, page):
+    """Return true if news should be display in page"""
+    return (not page.paginator
+            or page.name == news_page_name(news, page.website.conf.site))
+
+
+@jinja2.pass_context
+def news_page(context, site_news):
+    """
+    - keep same year
+    - (reverse) sort by date
+    """
+    page = context['page']
+    site = context['site']
+    if page.paginator:
+        name_selection = (news for news in site_news
+                          if news_page_name(news, site) == page.name)
+    else:
+        name_selection = site_news
+    return sort_by_date(name_selection, reverse=True)
+
+
+@jinja2.pass_context
+def dropdown_items(context, nav_items):
+    """Return the dropdown_items if item is a dict else {}"""
+    page = context['page']
+    nav_item = nav_items[page.menu_item]
+    return nav_item if isinstance(nav_item, dict) else {}
+
+
+def get_fullname(teams: dict, shortname: str) -> str:
+    """Return fullname from shortname"""
+    try:
+        return teams[shortname]['fullname']
+    except KeyError:
+        # team entry does not belongs to research teams list
+        return shortname
+
+
+def real_teams(sem_teams: list) -> bool:
+    """Return True if team is not in exclude names"""
+    return bool(sem_teams) and sem_teams[0].upper() not in {
+        'COLLOQUIUM', 'ENTR', 'AUTRE'}
+
+
+@jinja2.pass_context
+def teams(context, sem_teams) -> str:
+    """
+    Format team names such as:
+    Team1,
+    Team1 and Team2
+    Team1, Team2 and Team3
+    """
+
+    t_dict = context['teams']
+
+    if sem_teams:
+        if len(sem_teams) == 1:
+            return get_fullname(t_dict, sem_teams[0])
+        else:
+            return "{} et {}".format(', '.join(get_fullname(t_dict, team)
+                                               for team in sem_teams[:-1]),
+                                     get_fullname(t_dict, sem_teams[-1]))
+    else:
+        return ''
+
+
+@jinja2.pass_context
+def organizing_teams(context, sem_teams) -> str:
+    """
+    Format team names such as:
+    organisé par l'équipe Team1,
+    organisé par les équipes Team1 et Team2
+    """
+
+    if not real_teams(sem_teams):
+        return ''
+
+    t_dict = context['teams']
+
+    def link_team(team: str) -> str:
+        """Return a html link with the team fullname"""
+        if team in t_dict:
+            target = url(context, f"teams/{team.lower()}.html")
+            return f'''\
+<a href="{target}">{get_fullname(t_dict, team)}</a>\
+'''
+        else:
+            return team
+
+    if sem_teams:
+        if len(sem_teams) == 1:
+            return f"organisé par l'équipe {link_team(sem_teams[0])}"
+        else:
+            return "organisé par les équipes {} et {}".format(
+                ', '.join(link_team(team) for team in sem_teams[:-1]),
+                link_team(sem_teams[-1]))
+    else:
+        return ''