sgelt 4.8.1__tar.gz

sgelt-4.8.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 IRMA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sgelt-4.8.1/MANIFEST.in

@@ -0,0 +1,6 @@
+# Include the README
+include README.md
+
+# Include the data files
+recursive-include src/sgelt/theme *
+include src/sgelt/py.typed

sgelt-4.8.1/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.1
+Name: sgelt
+Version: 4.8.1
+Summary: SGELT: Site GEnerator for Labs and Teams
+Author-email: Matthieu Boileau <matthieu.boileau@math.unistra.fr>
+License: MIT
+Project-URL: Homepage, https://gitlab.math.unistra.fr/irma/sgelt
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bs4
+Requires-Dist: datetimejson
+Requires-Dist: icalendar==4.1.0
+Requires-Dist: jinja2
+Requires-Dist: livereload
+Requires-Dist: markdown
+Requires-Dist: markdown_link_attr_modifier
+Requires-Dist: python-frontmatter
+Requires-Dist: shortcodes
+Requires-Dist: unidecode
+Requires-Dist: watchdog
+Provides-Extra: tests
+Requires-Dist: faker; extra == "tests"
+Requires-Dist: freezegun; extra == "tests"
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: pytest-xdist[psutil]; extra == "tests"
+Requires-Dist: pytest-mock; extra == "tests"
+
+# SGELT: Site GEnerator for Labs and Teams
+
+## Installation
+
+* Create a python virtual environment :
+
+```bash
+virtualenv .venv/
+```
+
+* Activate it
+
+```bash
+source .venv/bin/activate
+```
+
+* Install the package and its dependencies :
+
+```bash
+pip install sgelt --index-url https://gitlab.math.unistra.fr/api/v4/projects/653/packages/pypi/simple
+```
+
+## Build a website
+
+### Files organization
+
+* `config.yml` describes the site configuration
+* `content/` dir contains markdown files
+* `agenda.json` contains all events data
+* `teams.json` contains teams data
+
+### Edit content
+
+* setup configuration in `config.yml`
+* edit `content/` dir.
+* generate json data files
+
+### Build and serve
+
+To build all site files, run :
+
+```bash
+sgelt
+```
+
+in the project directory.
+Output files will be written in `output/` dir.
+
+### Build and serve
+
+To serve the website and rebuild automatically when the content has changed:
+
+```bash
+sgelt -a -s
+```
+
+To open the homepage in a web browser, add:
+
+```bash
+sgelt -a -s -b
+```
+
+### Get help with CLI
+
+```bash
+sgelt -h
+```
+
+## Tests
+
+### Run tests using tox
+
+Tox setup the appropriate environments and run tests using pytest:
+
+```bash
+pip install tox  # install tox
+tox  # run
+```
+
+### Run tests using pytest
+
+```bash
+pip install -e .[tests]  # install dependencies for tests
+pytest -sv tests/  # run tests
+```

sgelt-4.8.1/README.md

@@ -0,0 +1,85 @@
+# SGELT: Site GEnerator for Labs and Teams
+
+## Installation
+
+* Create a python virtual environment :
+
+```bash
+virtualenv .venv/
+```
+
+* Activate it
+
+```bash
+source .venv/bin/activate
+```
+
+* Install the package and its dependencies :
+
+```bash
+pip install sgelt --index-url https://gitlab.math.unistra.fr/api/v4/projects/653/packages/pypi/simple
+```
+
+## Build a website
+
+### Files organization
+
+* `config.yml` describes the site configuration
+* `content/` dir contains markdown files
+* `agenda.json` contains all events data
+* `teams.json` contains teams data
+
+### Edit content
+
+* setup configuration in `config.yml`
+* edit `content/` dir.
+* generate json data files
+
+### Build and serve
+
+To build all site files, run :
+
+```bash
+sgelt
+```
+
+in the project directory.
+Output files will be written in `output/` dir.
+
+### Build and serve
+
+To serve the website and rebuild automatically when the content has changed:
+
+```bash
+sgelt -a -s
+```
+
+To open the homepage in a web browser, add:
+
+```bash
+sgelt -a -s -b
+```
+
+### Get help with CLI
+
+```bash
+sgelt -h
+```
+
+## Tests
+
+### Run tests using tox
+
+Tox setup the appropriate environments and run tests using pytest:
+
+```bash
+pip install tox  # install tox
+tox  # run
+```
+
+### Run tests using pytest
+
+```bash
+pip install -e .[tests]  # install dependencies for tests
+pytest -sv tests/  # run tests
+```

sgelt-4.8.1/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=61.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sgelt"
+authors = [
+    { name = "Matthieu Boileau", email = "matthieu.boileau@math.unistra.fr" },
+]
+description = "SGELT: Site GEnerator for Labs and Teams"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "bs4",
+    "datetimejson",
+    "icalendar==4.1.0",
+    "jinja2",
+    "livereload",
+    "markdown",
+    "markdown_link_attr_modifier",
+    "python-frontmatter",
+    "shortcodes",
+    "unidecode",
+    "watchdog",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+tests = [
+    "faker",
+    "freezegun",
+    "pytest",
+    "pytest-cov",
+    "pytest-xdist[psutil]",
+    "pytest-mock",
+]
+
+[project.license]
+text = "MIT"
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.urls]
+Homepage = "https://gitlab.math.unistra.fr/irma/sgelt"
+
+[project.scripts]
+sgelt = "sgelt.main:main"
+
+[tool.setuptools]
+include-package-data = true
+license-files = ["LICENSE"]
+package-dir = { "" = "src" }
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = false
+
+[tool.setuptools.dynamic.version]
+attr = "sgelt.__version__"
+
+[tool.setuptools.package-data]
+sgelt = ["py.typed", "sgelt/theme/*"]

sgelt-4.8.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sgelt-4.8.1/src/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-4.8.1/src/sgelt/__main__.py

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

sgelt-4.8.1/src/sgelt/__version__.py

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

sgelt-4.8.1/src/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-4.8.1/src/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-4.8.1/src/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()))