aerographite 1.0.0__tar.gz

aerographite-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Alice
+
+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.

aerographite-1.0.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: aerographite
+Version: 1.0.0
+Summary: Tiny lightweight static site generator written in Python that uses markdown and liquid to generate a website.
+Author-email: Alice Sell <alice@alicela1n.space>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/alicela1n/aerographite
+Project-URL: Issues, https://gitlab.com/alicela1n/aerographite/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<a href='https://ko-fi.com/S6S2A9XRF' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi6.png?v=6' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>
+
+# Aerographite
+Tiny lightweight static site generator written in Python that uses markdown and liquid to generate a website.
+
+# How it works
+The way it works is simple by design. The `aerographite` script checks for a `site` directory, which is your website's source directory. A template `site_template` is provided as a submodule, which can be copied and modified for your site. The `(site_directory)/templates` directory contains [liquid](https://shopify.github.io/liquid/) templates for generating the html skeleton of your website. [Markdown](https://www.markdownguide.org/) is used for the webpage contents. The index.md is the markdown file that generates the front page of the website.
+
+You can put markdown files in the site directory and have them generated as `(site_directory)/(page name)`. You can also put html in the markdown files and it will render in the body.To customize the html outside the body use templates. For javascript you can source your scripts either in the markdown files or html template. You can also have blog-style posts by putting markdown files in the `site/(posts_directory)/` directory. `posts_directory` is by default `posts`.
+
+The name for the posts needs to be formatted as: `(posts_directory)/YYYY-MM-DD-title.md`.
+
+The posts need to have a metadata header:
+```
+title: Post Title
+date: YYYY-MM-DD HH:mm
+```
+
+Posts will be indexed in `/posts` which you can link in index.md or anywhere else.
+
+The `(site_directory)/files/` directory is for any miscellaneous files that get copied to the output directory `out/`.
+
+The generated website is outputted to the output directory ready to be deployed to a web server or wherever.
+
+# Configuration
+You can configure many things, such as blog post generation, the name of the index page, rss feed generation, and the posts directory.
+
+To configure these things, copy the `config_template.yaml` to your site directory.
+
+If you change the `posts_directory` you must also rename it in your site directory, since that is the directory it will look for at generation time. This will change the url where your posts are, for example if you want it to be `/blog` such as `example.com/blog` change the `posts_directory` to `blog`.
+
+# RSS Feed Generation
+You can generate an RSS feed `(posts_directory)/rss.xml` by setting `rss_feed_generation` in the `config.yaml` to `True`. You need to set a `site_url`, `language`, and `feed_description`. If you do not set an `index_page_title` it uses the `site_url` as the RSS feed title.
+
+# Installation
+If you want to install aerographite from the pip repositories, run:
+```
+$ pip3 install aerographite
+```
+
+If youw want to install aerographite from this repo, follow these instructions:
+
+First you need to install the requirements:
+```
+$ pip3 install -r requirements.txt
+```
+
+Next, install aerographite using pip:
+```
+$ python3 -m pip install .
+```
+
+# How to use
+
+Provide your own site directory or use the template and modify it to your needs:
+```
+$ git submodule update --init
+$ cp site-template (site_location)
+```
+
+Next, edit the site how you see fit.
+
+Finally, to generate a website run:
+```
+$ aerographite (site_directory) (output_directory)
+```
+
+To view your website locally, run a web server:
+```
+$ python3 -m http.server -d (output_directory)
+```
+
+# Screenshots
+Here are some screenshots of the example site to demonstrate what aerographite can do.
+
+![Home Page](/images/home.png)
+![Posts Page](/images/posts.png)
+![Example Post](/images/example-post.png)
+![About Page](/images/about.png)

aerographite-1.0.0/README.md

@@ -0,0 +1,79 @@
+<a href='https://ko-fi.com/S6S2A9XRF' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi6.png?v=6' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>
+
+# Aerographite
+Tiny lightweight static site generator written in Python that uses markdown and liquid to generate a website.
+
+# How it works
+The way it works is simple by design. The `aerographite` script checks for a `site` directory, which is your website's source directory. A template `site_template` is provided as a submodule, which can be copied and modified for your site. The `(site_directory)/templates` directory contains [liquid](https://shopify.github.io/liquid/) templates for generating the html skeleton of your website. [Markdown](https://www.markdownguide.org/) is used for the webpage contents. The index.md is the markdown file that generates the front page of the website.
+
+You can put markdown files in the site directory and have them generated as `(site_directory)/(page name)`. You can also put html in the markdown files and it will render in the body.To customize the html outside the body use templates. For javascript you can source your scripts either in the markdown files or html template. You can also have blog-style posts by putting markdown files in the `site/(posts_directory)/` directory. `posts_directory` is by default `posts`.
+
+The name for the posts needs to be formatted as: `(posts_directory)/YYYY-MM-DD-title.md`.
+
+The posts need to have a metadata header:
+```
+title: Post Title
+date: YYYY-MM-DD HH:mm
+```
+
+Posts will be indexed in `/posts` which you can link in index.md or anywhere else.
+
+The `(site_directory)/files/` directory is for any miscellaneous files that get copied to the output directory `out/`.
+
+The generated website is outputted to the output directory ready to be deployed to a web server or wherever.
+
+# Configuration
+You can configure many things, such as blog post generation, the name of the index page, rss feed generation, and the posts directory.
+
+To configure these things, copy the `config_template.yaml` to your site directory.
+
+If you change the `posts_directory` you must also rename it in your site directory, since that is the directory it will look for at generation time. This will change the url where your posts are, for example if you want it to be `/blog` such as `example.com/blog` change the `posts_directory` to `blog`.
+
+# RSS Feed Generation
+You can generate an RSS feed `(posts_directory)/rss.xml` by setting `rss_feed_generation` in the `config.yaml` to `True`. You need to set a `site_url`, `language`, and `feed_description`. If you do not set an `index_page_title` it uses the `site_url` as the RSS feed title.
+
+# Installation
+If you want to install aerographite from the pip repositories, run:
+```
+$ pip3 install aerographite
+```
+
+If youw want to install aerographite from this repo, follow these instructions:
+
+First you need to install the requirements:
+```
+$ pip3 install -r requirements.txt
+```
+
+Next, install aerographite using pip:
+```
+$ python3 -m pip install .
+```
+
+# How to use
+
+Provide your own site directory or use the template and modify it to your needs:
+```
+$ git submodule update --init
+$ cp site-template (site_location)
+```
+
+Next, edit the site how you see fit.
+
+Finally, to generate a website run:
+```
+$ aerographite (site_directory) (output_directory)
+```
+
+To view your website locally, run a web server:
+```
+$ python3 -m http.server -d (output_directory)
+```
+
+# Screenshots
+Here are some screenshots of the example site to demonstrate what aerographite can do.
+
+![Home Page](/images/home.png)
+![Posts Page](/images/posts.png)
+![Example Post](/images/example-post.png)
+![About Page](/images/about.png)

aerographite-1.0.0/aerographite.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: aerographite
+Version: 1.0.0
+Summary: Tiny lightweight static site generator written in Python that uses markdown and liquid to generate a website.
+Author-email: Alice Sell <alice@alicela1n.space>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/alicela1n/aerographite
+Project-URL: Issues, https://gitlab.com/alicela1n/aerographite/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Web Environment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<a href='https://ko-fi.com/S6S2A9XRF' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://storage.ko-fi.com/cdn/kofi6.png?v=6' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>
+
+# Aerographite
+Tiny lightweight static site generator written in Python that uses markdown and liquid to generate a website.
+
+# How it works
+The way it works is simple by design. The `aerographite` script checks for a `site` directory, which is your website's source directory. A template `site_template` is provided as a submodule, which can be copied and modified for your site. The `(site_directory)/templates` directory contains [liquid](https://shopify.github.io/liquid/) templates for generating the html skeleton of your website. [Markdown](https://www.markdownguide.org/) is used for the webpage contents. The index.md is the markdown file that generates the front page of the website.
+
+You can put markdown files in the site directory and have them generated as `(site_directory)/(page name)`. You can also put html in the markdown files and it will render in the body.To customize the html outside the body use templates. For javascript you can source your scripts either in the markdown files or html template. You can also have blog-style posts by putting markdown files in the `site/(posts_directory)/` directory. `posts_directory` is by default `posts`.
+
+The name for the posts needs to be formatted as: `(posts_directory)/YYYY-MM-DD-title.md`.
+
+The posts need to have a metadata header:
+```
+title: Post Title
+date: YYYY-MM-DD HH:mm
+```
+
+Posts will be indexed in `/posts` which you can link in index.md or anywhere else.
+
+The `(site_directory)/files/` directory is for any miscellaneous files that get copied to the output directory `out/`.
+
+The generated website is outputted to the output directory ready to be deployed to a web server or wherever.
+
+# Configuration
+You can configure many things, such as blog post generation, the name of the index page, rss feed generation, and the posts directory.
+
+To configure these things, copy the `config_template.yaml` to your site directory.
+
+If you change the `posts_directory` you must also rename it in your site directory, since that is the directory it will look for at generation time. This will change the url where your posts are, for example if you want it to be `/blog` such as `example.com/blog` change the `posts_directory` to `blog`.
+
+# RSS Feed Generation
+You can generate an RSS feed `(posts_directory)/rss.xml` by setting `rss_feed_generation` in the `config.yaml` to `True`. You need to set a `site_url`, `language`, and `feed_description`. If you do not set an `index_page_title` it uses the `site_url` as the RSS feed title.
+
+# Installation
+If you want to install aerographite from the pip repositories, run:
+```
+$ pip3 install aerographite
+```
+
+If youw want to install aerographite from this repo, follow these instructions:
+
+First you need to install the requirements:
+```
+$ pip3 install -r requirements.txt
+```
+
+Next, install aerographite using pip:
+```
+$ python3 -m pip install .
+```
+
+# How to use
+
+Provide your own site directory or use the template and modify it to your needs:
+```
+$ git submodule update --init
+$ cp site-template (site_location)
+```
+
+Next, edit the site how you see fit.
+
+Finally, to generate a website run:
+```
+$ aerographite (site_directory) (output_directory)
+```
+
+To view your website locally, run a web server:
+```
+$ python3 -m http.server -d (output_directory)
+```
+
+# Screenshots
+Here are some screenshots of the example site to demonstrate what aerographite can do.
+
+![Home Page](/images/home.png)
+![Posts Page](/images/posts.png)
+![Example Post](/images/example-post.png)
+![About Page](/images/about.png)

aerographite-1.0.0/aerographite.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+aerographite.egg-info/PKG-INFO
+aerographite.egg-info/SOURCES.txt
+aerographite.egg-info/dependency_links.txt
+aerographite.egg-info/entry_points.txt
+aerographite.egg-info/top_level.txt
+src/aerographite/__init__.py
+src/aerographite/__main__.py
+src/aerographite/config_template.yaml
+src/aerographite/litestatic.py

aerographite-1.0.0/aerographite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aerographite-1.0.0/aerographite.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aerographite = aerographite:main

aerographite-1.0.0/aerographite.egg-info/top_level.txt

@@ -0,0 +1 @@
+aerographite

aerographite-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aerographite"
+version = "1.0.0"
+authors = [
+  { name="Alice Sell", email="alice@alicela1n.space" },
+]
+description = "Tiny lightweight static site generator written in Python that uses markdown and liquid to generate a website."
+readme = {file = "README.md", content-type = "text/markdown"}
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Environment :: Web Environment",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[tool.setuptools]
+packages = ["aerographite"]
+
+[tool.setuptools.package-dir]
+aerographite = "src/aerographite"
+
+[tool.setuptools.package-data]
+"aerographite" = ["*.yaml"]
+
+install_requires = [
+    "feedgen",
+    "marko",
+    "python-frontmatter",
+    "python-liquid",
+    "pygments",
+    "pyyaml"
+]
+
+[project.scripts]
+aerographite = "aerographite:main"
+
+[project.urls]
+Homepage = "https://gitlab.com/alicela1n/aerographite"
+Issues = "https://gitlab.com/alicela1n/aerographite/issues"

aerographite-1.0.0/setup.cfg

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

aerographite-1.0.0/src/aerographite/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.0.1"
+__author__ = "Alice"
+PACKAGE_NAME = "litestatic"
+from .litestatic import main

aerographite-1.0.0/src/aerographite/__main__.py

@@ -0,0 +1,4 @@
+from .litestatic import main
+
+if __name__ == '__main__':
+    main()

aerographite-1.0.0/src/aerographite/config_template.yaml

@@ -0,0 +1,10 @@
+blog_post_generation: True
+index_page_title:
+posts_directory: posts
+
+# Needed for RSS feed generation
+generate_rss_feed: False
+site_url:
+url_prefix: # Example: http:// or https:// or https://www. (if you use http to https redirection you you could use http here for better compatibility with proxy servers)
+language: en
+feed_description:

aerographite-1.0.0/src/aerographite/litestatic.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+from marko import Markdown
+from pathlib import Path
+from liquid import Template
+from liquid import Environment
+from liquid import FileSystemLoader
+import os
+import shutil
+import frontmatter
+import datetime
+markdown = Markdown(extensions=['codehilite'])
+import pygments
+import yaml
+import argparse
+from importlib.resources import files
+from feedgen.feed import FeedGenerator
+
+# Each post is a markdown file which gets parsed into an object which contains it's metadata, date,
+# and HTML content (converted from the Markdown).
+class Post:
+    def __init__(self, name, title, date, html):
+        self.name = name
+        self.title = title
+        self.date = datetime.datetime.strptime(date, '%Y-%m-%d %H:%M').replace(tzinfo=datetime.timezone.utc)
+        self.html = html
+
+# Command line argument parser
+parser = argparse.ArgumentParser()
+parser.add_argument("site_directory", type=str, help="The website source directory to be generated")
+parser.add_argument("output_directory", type=str, help="The directory to output the generated website")
+
+# generate_index_page(): Produce the index.html file which will be the front page of the website
+def generate_index_page(index_page_title, site_directory, templates_directory, output_directory):
+    env = Environment(loader=FileSystemLoader(f"{site_directory}/{templates_directory}/"))
+    template = env.get_template("index.html")
+
+    if not os.path.exists(f"{output_directory}"):
+        os.makedirs(f"{output_directory}")
+
+    with open(f"{site_directory}/index.md", "r") as index_file:
+        index_buffer = frontmatter.load(index_file)
+        index_body = markdown.convert(index_buffer.content)
+
+    with open(f"{output_directory}/index.html", "w") as output_file:
+        print(f"Generating {output_directory}/index.html")
+        output_file.write(template.render(page_title=index_page_title,index_body=index_body,))
+
+# generate_html_pages(): Produce the HTML pages out of markdown files that will make up the site
+def generate_html_pages(site_directory, templates_directory, output_directory):
+    env = Environment(loader=FileSystemLoader(f"{site_directory}/{templates_directory}/"))
+
+    if not os.path.exists(f"{output_directory}"):
+        os.makedirs(f"{output_directory}")
+
+    page_files = Path(site_directory).glob("*.md")
+    for page in page_files:
+        with open(page, "r") as md_file:
+            page_buffer = frontmatter.load(md_file)
+            page_body = markdown.convert(page_buffer.content)
+            page_name = str(page.with_suffix(''))
+            page_name = page_name.split('/')[-1]
+
+        if not page_name == "index": # Exclude index
+            if not os.path.exists(f"{output_directory}/{page_name}"):
+                os.makedirs(f"{output_directory}/{page_name}")
+            
+            if os.path.exists(f"{site_directory}/{templates_directory}/{page_name}.html"):
+                template = env.get_template(f"{page_name}.html")
+            else:
+                template = env.get_template("page.html")
+
+            with open(f"{output_directory}/{page_name}/index.html", "w") as output_file:
+                print(f"Generating {output_directory}/{page_name}/index.html")
+                output_file.write(template.render(page_title=page_name, page_body=page_body,))
+
+# generate_posts(): Produce an array of post objects
+def generate_posts(site_directory, posts_directory):
+    post_files = Path(f"{site_directory}/{posts_directory}").glob("*.md")
+    
+    posts = []
+    for post in post_files:
+        with open(post, "r") as md_file:
+            # Remove the extension from the post name
+            post_name = str(post.with_suffix(''))
+            # Remove the site_directory and post_directory from the post name
+            post_name = post_name.split('/')[-1]
+
+            post_buffer = frontmatter.load(md_file)
+            post_title = post_buffer['title']
+            post_date = post_buffer['date']
+            post_html = markdown.convert(post_buffer.content)
+            posts.append(Post(post_name, post_title, post_date, post_html))
+
+    return posts
+
+# generate_post_files(): Generate the html files for the posts
+def generate_post_files(posts, site_directory, templates_directory, posts_directory, output_directory):
+    env = Environment(loader=FileSystemLoader(f"{site_directory}/{templates_directory}/"))
+    template = env.get_template("post-template.html")
+
+    if not os.path.exists(f"{output_directory}/{posts_directory}"):
+        os.makedirs(f"{output_directory}/{posts_directory}")
+
+    for post in posts:
+        if not os.path.exists(f"{output_directory}/{posts_directory}/{post.name}"):
+            os.makedirs(f"{output_directory}/{posts_directory}/{post.name}")
+
+        with open(f"{output_directory}/{posts_directory}/{post.name}/index.html", "w") as output_file:
+            print(f"Generating {output_directory}/{posts_directory}/{post.name}")
+            output_file.write(template.render(page_title=post.title, post_title=post.title, post_date=post.date, post_html=post.html,))
+
+# generate_post_index(): Generate the post index
+def generate_post_index(posts, site_directory, templates_directory, posts_directory, output_directory):
+    posts_list = []
+
+    for post in posts:
+        posts_dict = {"title": post.title, "date": post.date, "path": f"{post.name}"} 
+        posts_list.append(posts_dict)
+    
+    posts_data = { "posts" : posts_list }
+
+    env = Environment(loader=FileSystemLoader(f"{site_directory}/{templates_directory}/"))
+    template = env.get_template("posts-index.html")
+
+    with open(f"{output_directory}/{posts_directory}/index.html", "w") as output_file:
+        print(f"Generating {output_directory}/{posts_directory}/index.html")
+        output_file.write(template.render(page_title="Posts", **posts_data))
+
+# generate_rss_feed: Generate an RSS feed and populate it with your blog posts
+def generate_rss_feed(posts, feed_title, feed_description, site_url, url_prefix, language, output_directory, posts_directory):
+    feed = FeedGenerator()
+    feed.title(feed_title)
+    feed.description(feed_description)
+    feed.language(language)
+    feed.id(f"posts")
+    feed.link( href=f"{site_url}/{posts_directory}", rel='self')
+    # Use post metadata for RSS feed
+    for post in posts:
+        feed_entry = feed.add_entry()
+        feed_entry.id(f"{post.name}")
+        feed_entry.title(post.title)
+        feed_entry.content(content=post.html, type='text/html')
+        feed_entry.pubDate(post.date)
+        feed_entry.link(href=f"{url_prefix}{site_url}/{posts_directory}/{post.name}")
+
+    feed.atom_file(f"{output_directory}/{posts_directory}/rss.xml", pretty=True)
+
+# copy_files_to_out(): Copy the files in the files directory to the output directory
+def copy_files_to_out(site_directory, files_directory, output_directory):
+    shutil.copytree(f"{site_directory}/{files_directory}", output_directory, symlinks=False, ignore=None, copy_function=shutil.copy2, ignore_dangling_symlinks=False, dirs_exist_ok=True)
+
+# main(): Main function
+def main():
+    args = parser.parse_args()
+    site_directory = args.site_directory
+    files_directory = "files"
+    templates_directory = "templates"
+    config_template_path = files("litestatic").joinpath("config_template.yaml")
+
+    if site_directory == ".":
+        site_directory = Path.cwd()
+
+    if not os.path.exists(site_directory):
+        print("No site directory found!")
+        print("Provide a site directory or create one using the site_template!")
+        exit();
+
+    output_directory = args.output_directory
+    if not os.path.exists(output_directory):
+        os.makedirs(output_directory)
+
+    if os.path.isfile(f"{site_directory}/config.yaml"):
+        config = yaml.safe_load(Path(f"{site_directory}/config.yaml").read_text()) # Read the config file
+    else:
+        config = yaml.safe_load(Path(config_template_path).read_text()) # Fall back to config_template.yaml
+
+    
+    index_page_title = config["index_page_title"]
+    generate_index_page(index_page_title, site_directory, templates_directory, output_directory)
+    generate_html_pages(site_directory, templates_directory, output_directory)
+
+    # Fall back to posts if posts_directory not set
+    if config["blog_post_generation"] == True:
+        if config["posts_directory"]:
+            posts_directory = config["posts_directory"]
+        else:
+            posts_directory = "posts"
+
+        posts = generate_posts(site_directory, posts_directory)
+        generate_post_files(posts, site_directory, templates_directory, posts_directory, output_directory)
+        generate_post_index(posts, site_directory, templates_directory, posts_directory, output_directory)
+
+    # RSS feed generation
+    if config["generate_rss_feed"] == True:
+        site_url = config["site_url"]
+        url_prefix = config["url_prefix"]
+        language = config["language"]
+        feed_description = config["feed_description"]
+        # Get the index_page_title from the site url if not set explicitly
+        if not index_page_title:
+            index_page_title = f"{site_url}"
+        generate_rss_feed(posts, index_page_title, feed_description, site_url, url_prefix, language, output_directory, posts_directory)
+
+    copy_files_to_out(site_directory, files_directory, output_directory)
+
+if __name__ == '__main__':
+    main()