re-plugin-pack 2025.6.1__py3-none-any.whl

re_plugin_pack/__init__.py

@@ -0,0 +1,6 @@
+from .plugins.date_normalizer import DateNormalizer
+from .plugins.drafts import Drafts
+from .plugins.latest_entries import LatestEntries
+from .plugins.next_prev import NextPrevPlugin
+
+__all__ = [LatestEntries, NextPrevPlugin, Drafts, DateNormalizer]

re_plugin_pack/plugins/date_normalizer.py

@@ -0,0 +1,49 @@
+import datetime
+from typing import Any
+
+from dateutil import parser as date_parser
+from render_engine import Collection, Page, Site
+from render_engine.plugins import hook_impl
+
+
+class DateNormalizer:
+    default_settings = {}
+
+    @staticmethod
+    @hook_impl
+    def pre_build_site(
+        site: Site,
+        settings: dict[str, Any],
+    ) -> None:
+        """
+        Normalize dates in pages to be datetime for proper functioning
+
+        :param site: Site
+        :param settings: Settings object
+        :return: None
+        """
+        for entry in site.route_list.values():
+            match entry:
+                case Page():
+                    DateNormalizer._handle_date(entry)
+                case Collection():
+                    for page in entry:
+                        DateNormalizer._handle_date(page)
+
+    @staticmethod
+    def _handle_date(entry: Page) -> None:
+        """
+        Normalize the date attribute in a Page
+
+        :return: None
+        """
+        if hasattr(entry, 'date'):
+            match entry.date:
+                case datetime.date():
+                    entry.date = date_parser.parse(str(entry.date))
+                case str():
+                    entry.date = date_parser.parse(entry.date)
+                case datetime.datetime():
+                    pass
+                case _:
+                    raise AttributeError(f'Unknown date type: {type(entry.date)} {entry.date}')

re_plugin_pack/plugins/drafts.py

@@ -0,0 +1,24 @@
+"""Plugin to enable skipping draft pages"""
+
+from render_engine import Collection, Site
+from render_engine.plugins import hook_impl
+
+
+class Drafts:
+    default_settings = {'show_drafts': True}
+
+    @staticmethod
+    @hook_impl
+    def pre_build_collection(collection: Collection, site: Site, settings: dict):
+        """
+        If enabled, skip pages with a draft attribute that is set to True
+
+        :param collection: Collection object to run on
+        :param site: Site object
+        :param settings: Settings for the plugin
+        """
+        settings = settings['Drafts']
+        if settings['show_drafts']:
+            print('Showing draft pages.')
+            return
+        collection.pages = [page for page in collection if not getattr(page, 'draft', False)]

re_plugin_pack/plugins/latest_entries.py

@@ -0,0 +1,133 @@
+"""Plugin for giving the latest entries"""
+
+from render_engine import Collection, Page, Site
+from render_engine.plugins import hook_impl
+
+
+class LatestEntries:
+    """
+    Adds a dictionary to the index page's template_vars:
+
+    default_settings = {
+        "collection": ["url"],
+        "entries": ["title", "url"],
+        "pages": ["index"],
+        "max_entries": 3,
+    }
+
+    To override the default number of entries add to the registration:
+    {<collection title>: <max entries>}
+    To disable set max entries to 0 for that collection
+    To print all entries for a given collection set max entries to a negative number
+
+    Can be registered on the Site object:
+    app.register_plugins(LatestEntries, LatestEntries=<settings overrides>)
+
+    Can be registered for an individual Page include it in the definition of the page:
+    @app.page
+    class MyPage(Page):
+        plugins = [
+            (
+                LatestEntries,
+                {
+                    "Collection1": 5,  # Include the 5 most recent entries
+                    "Collection2": 0,  # Exclude this collection
+                    "Collection3": -1,  # Include all entries in the collection
+                },
+            )
+        ]
+    NOTE: If registering the plugin for an individual page the "page" part of the settings
+          is irrelevant and not looked at. That settings is for when registering for the site.
+
+    NOTE: "Most recent" is defined by the sort order for the given collection.
+          The default for a Collection is "title" and the default for a Blog is date.
+          You can override the sort order (which will affect the sorting for everything,
+          just this plugin) by initializing the Collection object with the following attribute:
+                sort_by = <sort attribute>
+
+    To use put this into your index.html template or content:
+    {% for collection, collection_data in COLLECTIONS.items() %}
+        Most recent <a href="{{ collection_data['url'] }}">{{ collection }}</a> entries:
+        <ul>
+        {% for entry in collection_data['entries'] %}
+            <li><a href="{{ entry['url'] }}">{{ entry['title'] }}</a></li>
+        {% endfor %}
+        </ul>
+    {% endfor %}
+
+    NOTE: Above example is using the default settings.
+    """
+
+    default_settings = {
+        'collection': ['url'],
+        'entries': ['title', 'url'],
+        'pages': ['index'],
+        'max_entries': 3,
+    }
+
+    @staticmethod
+    @hook_impl
+    def pre_build_site(site: Site, settings: dict):
+        """
+        Pre-build site hook
+
+        :param site: Site object
+        :param settings: Settings dictionary [Not currently used but required by the hook]
+        """
+        settings = settings['LatestEntries']
+        pages = settings.get('pages', list())
+        for page_entry in pages:
+            page = site.route_list[page_entry]
+            LatestEntries.build_latest_entries(site=site, page=page, settings=settings)
+
+    @staticmethod
+    @hook_impl
+    def render_content(page: Page, settings: dict, site: Site):
+        """
+        Render content hook
+
+        :param page: The page to update
+        :param settings: The settings for the plugin
+        :param site: The Site object.
+        """
+        LatestEntries.build_latest_entries(site, page, settings['LatestEntries'])
+
+    @staticmethod
+    def build_latest_entries(site: Site, page: Page, settings: dict):
+        """
+        Update the page with the latest entries.
+
+        :param page: The page to update
+        :param settings: The settings for the plugin
+        :param site: The Site object.
+        """
+        collections = dict()
+        for name, collection in site.route_list.items():
+            if isinstance(collection, Collection):
+                if not (max_entries := settings.get(collection.title, settings['max_entries'])):
+                    continue
+                if max_entries < 0:
+                    max_entries = len(collection.sorted_pages)
+                collections[collection.title] = {'entries': list()}
+                for attr in settings['collection']:
+                    if attr == 'url':
+                        value = f'/{collection.routes[0]}/'
+                    else:
+                        value = getattr(collection, attr, None)
+                    collections[collection.title][attr] = value
+                for entry in collection.sorted_pages[:max_entries]:
+                    entry_dict = dict()
+                    for attr in settings['entries']:
+                        if attr == 'url':
+                            value = f'/{entry.routes[0]}/{entry._slug}.html'
+                        else:
+                            value = getattr(entry, attr, None)
+                        entry_dict[attr] = value
+                    collections[collection.title]['entries'].append(entry_dict)
+
+        if not hasattr(page, 'template_vars'):
+            page.template_vars = dict()
+        if existing_collections := page.template_vars.get('COLLECTIONS'):
+            existing_collections.update(collections)
+        else:
+            page.template_vars['COLLECTIONS'] = collections

re_plugin_pack/plugins/next_prev.py

@@ -0,0 +1,57 @@
+"""Plugin to add next & prev links to items in a collection"""
+
+from render_engine import Collection, Site
+from render_engine.plugins import hook_impl
+
+
+class NextPrevPlugin:
+    default_settings = {}
+
+    @staticmethod
+    @hook_impl
+    def pre_build_collection(collection: Collection, site: Site, settings: dict):
+        """
+        Update a list of pages with links for the previous and next posts abd the URL for the Collection archive.
+
+        Can be registered with the Site or one or more Collections.
+
+        Note that if the sort is reversed for the collection (which is the default for Blog) you will
+             want to have `reversed: true` for the settings of this plugin.
+
+        Example implementation:
+        {% if collection_url %}
+            <hr/>
+            <p style="text-align: center;">
+            {% if prev_url %}
+            Previous: <a href="{{ prev_url }}">{{ prev_title }}</a>&nbsp;&nbsp;&nbsp;&nbsp;
+            {% endif %}
+            {% if next_url %}
+            &nbsp;&nbsp;&nbsp;&nbsp;Next: <a href="{{ next_url }}">{{ next_title }}</a>
+            {% endif %}
+            </p>
+        {% endif %}
+
+        :param collection: Collection instance
+        :param site: Site object - not used but part of the prototype for this hook
+        :param settings: Plugin settings
+        """
+        settings = settings['NextPrevPlugin']
+        reverse = collection.sort_reverse
+        pages = collection.sorted_pages[::-1] if reverse else collection.sorted_pages
+        collection_url = collection.routes[0]
+        max_page = len(pages) - 1
+        for i, page in enumerate(pages):
+            template_vars = dict()
+            if i < max_page:
+                template_vars['next_url'] = pages[i + 1].url_for()
+                template_vars['next_title'] = pages[i + 1].title
+                for attr in settings.get('additional_attributes', list()):
+                    template_vars[f'next_{attr}'] = getattr(pages[i + 1], attr, None)
+            if i > 0:
+                template_vars['prev_url'] = pages[i - 1].url_for()
+                template_vars['prev_title'] = pages[i - 1].title
+                for attr in settings.get('additional_attributes', list()):
+                    template_vars[f'prev_{attr}'] = getattr(pages[i - 1], attr, None)
+            template_vars['collection_url'] = collection_url
+            template_vars['collection_title'] = collection._title
+            page.template_vars = template_vars

re_plugin_pack-2025.6.1.dist-info/METADATA

@@ -0,0 +1,380 @@
+Metadata-Version: 2.4
+Name: re-plugin-pack
+Version: 2025.6.1
+Summary: Plugin pack for render-engine static site generator
+Author: Dan Shernicoff
+Author-email: Dan Shernicoff <dan@brassnet.biz>
+License-Expression: MIT
+License-File: LICENSE.md
+Requires-Dist: render-engine>=2025.6.1
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/brass75/re-plugin-pack
+Project-URL: homepage, https://github.com/brass75/re-plugin-pack
+Description-Content-Type: text/markdown
+
+# re-plugin-pack
+
+[![Tests](https://github.com/brass75/re_plugin_pack/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/brass75/re_plugin_pack/actions/workflows/test.yml)
+[![Mastodon Follow](https://img.shields.io/mastodon/follow/109552736199041636?domain=https%3A%2F%2Ftwit.social&style=flat)](https://twit.social/@brass75)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+This is a plugin pack for the `render-engine` static site generator. It currently includes the
+following plugins:
+
+- [`LatestEntries`](#latestentries)
+- [`NextPrevPlugin`](#nextprevplugin)
+- [`Drafts`](#drafts)
+- [`DateNormalizer`](#datenormalizer)
+
+## Installation
+
+To install just run:
+
+```shell
+pip install re-plugin-pack
+```
+
+Once installed you can access the plugins by importing `re_plugin_pack`:
+
+```python
+import re_plugin_pack
+from re_plugin_pack import <plugin>
+```
+
+## `LatestEntries`
+
+This plugin will add a list of the latest entries for one or more `Collection`s to a given `Page`.
+It can be configured at the Page or `Site` levels and can be configured to provide the latest entries
+for any number of `Collection`s. The entries used are in the sort order as defined in the `Collection`
+object.
+
+### Settings
+
+The plugin has the following default settings:
+
+```python
+{
+    "collection": ["url"],
+    "entries": ["title", "url"],
+    "pages": ["index"],
+    "max_entries": 3,
+}
+```
+
+- `collection` - a list of attributes to include for the collection.
+- `entries` - a list of attributes to include for a given entry.
+- `pages` - a list of pages to add the `COLLECTIONS` entry to it's `template_vars` (Only needed when running as a
+`Site` plugin)
+- `max_entries` - The maximum number of entries to include for a collection. The default is 3. `-1` indicates
+that all entries should be populated.
+
+In addition to the default settings entries can be added for each `Collection` defining how many
+entries it should include:
+
+- Positive integer - Include up to the number specified entries. For example: `'Collection1': 5`
+will include the 5 latest entries in the `template_vars`.
+- `0` - Exclude this collection. For example: `'Collection2': 0` will not include `Collection2`
+in the `template_vars`.
+- Negative integer - Include all entries. For example: `'Collection3': -1` will include all
+entries for `Collection3` in the `template_vars`
+
+### `Page` level configuration
+
+To configure at the `Page` level just include `(LatestEntris, <settings_dict)` in the `plugins`
+attribute when declaring the `Page`. If no settings overrides are needed, include `LatestEntries`
+by itself in the `plugin` attribute.
+
+Example:
+
+```python
+from render_engine import Site, Page
+from re-plugin-pack import LatestEntries
+
+app = Site()
+@app.page
+class MyPage(Page):
+    plugins = [
+        (
+            LatestEntries,
+            {
+                "Collection1": 5,  # Include the 5 most recent entries
+                "Collection2": 0,  # Exclude this collection
+                "Collection3": -1,  # Include all entries in the collection
+            },
+        )
+    ]
+    ...
+```
+
+### `Site` level configuration
+
+To configure at the `Site` level call `app.register_plugins(LatestEntries, LatestEntries=<settings>)`
+if settings overrides are being used. To configure without additional settings, call
+`app.register_plugin(LatestEntries)`.
+
+Example:
+
+```python
+from render_engine import Site, Page
+from re-plugin-pack import LatestEntries
+
+app = Site()
+
+# The following will use the default settings overriding the pages to run on to be page1 and page2
+app.register_plugins(LatestEntries, LatestEntries={'pages': ['page1', 'page2']})
+
+# The following will only enable for the Blog collection:
+app.register_plugins(LatestEntries, LatestEntries={'max_entries': 0, 'Blog': 3})
+```
+
+NOTE: If configuring at the `Site` level the registration should be done _after_ adding all
+`Page` entries to the `Site`. When adding a `Page` to a `Site` all plugins registered to the
+`Site` are automatically registered to the new `Page` object.
+
+### Including in the `Page` template
+
+The latest entries will be added to the `COLLECTIONS` key of the `template_vars` for the `Page`
+and can be accessed in the template as `COLLECTIONS`.
+
+Example template implementation:
+
+```
+{% for collection, collection_data in COLLECTIONS.items() %}
+    Most recent <a href="{{ collection_data['url'] }}">{{ collection }}</a> entries:
+    <ul>
+    {% for entry in collection_data['entries'] %}
+        <li><a href="{{ entry['url'] }}">{{ entry['title'] }}</a></li>
+    {% endfor %}
+    </ul>
+{% endfor %}
+```
+
+## `NextPrevPlugin`
+
+This plugin will give each page in a `Collection` access to certain attributes of the next and
+previous pages in the collection. By default, only the URL and title of those pages will be
+made available, however additional attributes may also be requested via the settings. If an
+attributes is in the list to include but does not exist in the page(s) `None` will be used.
+This plugin runs at the `Collection` level and can be registered at the `Site` or `Collection`
+level.
+
+### Settings
+
+This plugin has no default settings. If you wish to add additional attributes, include in the
+registration a settings dictionary with a key of `additional_attributes` having a list of
+attributes as its value.
+
+### `Site` level configuration
+
+To configure at the `Site` level call `app.register_plugins(NextPrevPlugin, NextPrevPlugin=<settings>)`
+if settings overrides are being used. To configure without additional settings, call
+`app.register_plugin(NextPrevPlugin)`.
+
+Example:
+
+```python
+from render_engine import Site, Page
+from re-plugin-pack import NextPrevPlugin
+
+app = Site()
+
+# The following will include the date attribute in in the data made available.
+app.register_plugins(NextPrevPlugin, NextPrevPlugin={'additional_attributes': ['date']})
+
+# The following will not include any additional attributes
+app.register_plugins(NextPrevPlugin)
+```
+
+NOTE: If configuring at the `Site` level the registration should be done _after_ adding all
+`Collection` entries to the `Site`. When adding a `Collection` to a `Site` all plugins
+registered to the `Site` are automatically registered to the new `Collection` object.
+
+### `Collection` level configuration
+
+To configure at the `Page` level just include `(NextPrevPlugin, <settings_dict)` in the `plugins`
+attribute when declaring the `Collection`. If no settings overrides are needed, include
+`NextPrevPlugin` by itself in the `plugin` attribute.
+
+Example:
+
+```python
+from render_engine import Site, Page
+from re-plugin-pack import NextPrevPlugin
+
+app = Site()
+@app.page
+class MyPage(Page):
+    plugins = [
+        (
+            NextPrevPlugin,
+            {
+                'additional_attributes': [  # This will make the date and description attributes available
+                    'date',
+                    'description',
+                ]
+            },
+        )
+    ]
+    ...
+```
+
+### Including in the `Collection` template
+
+When run this plugin will add a dictionary with the requested data to the `template_vars` of
+each page in the `Collection`. The dictionary added looks like:
+
+```python
+{
+    'collection_url': <url>,
+    'collection_title': <title>,
+    'next_url': <url>,
+    'next_title': <title>,
+    'prev_url': <url>,
+    'prev_title': <title>,
+}
+```
+
+If `additional_attributes` are included in the settings, they will be in the dictionary as:
+`prev_<attr>: <value>` and `next_<attr>: <value>`.
+
+```
+{% if prev_url %}
+<span class="prev_data">
+Previous: <a href="{{ prev_url }}">{{ prev_title }}</a>
+</span>
+{% endif %}
+{% if next_url %}
+<span class="next_data">
+Next: <a href="{{ next_url }}">{{ next_title }}</a>
+</span>
+{% endif %}
+```
+
+## `Drafts`
+
+This is a plugin that will skip pages in a `Collection` that are marked as `draft`.  This allows
+you to have WIP posts and still make changes to other things without publishing things that are
+not ready to be posted.
+
+### Settings
+
+The `Drafts` plugin has a single setting:
+
+```python
+{
+    'show_drafts': True,
+}
+```
+
+When `show_drafts` is set to `False` the plugin will run, prior to rendering the `Collection`
+and remove all pages in the collection that have a `True` value for the `draft` attribute will
+not be rendered when building the site. This plugin runs at the `Collection` level and can be
+registered either `Site`-wide or for individual collections.
+
+**NOTE**: Plugins run in the reverse order of registration. If you are using both this and
+[`NextPrevPlugin`](NextPrevPlugin) make sure that you register `NextPrevPlugin` (or any similar
+plugin) _before_ you register `Drafts` or you might have unexpected results as pages that were
+processed will have been removed.
+
+### Making sure that drafts show locally but not on your production site
+
+In order to have this work effectively, so that you can see the draft posts locally when you
+use `render-engine serve`, you will need to differentiate between the environments. To
+accomplish this you can use an environment variable and add this line of code into your
+`app.py`:
+
+```python
+import os
+
+ENABLE_DRAFTS = {"show_drafts": os.environ.get("SHOW_DRAFTS", False)}
+```
+
+When you register the plugin make sure to include the `ENABLE_DRAFTS` as the settings
+for the plugin:
+
+```python
+import os
+from re_plugin_pack import Drafts
+from render_engine import Site, Collection
+
+ENABLE_DRAFTS = {"show_drafts": os.environ.get("SHOW_DRAFTS", False)}app=Site()
+
+# Either at the `Site` level:
+app.register_plugins(Drafts, Drafts=ENABLE_DRAFTS)
+
+# Or at the `Collection` level:
+@app.collection
+class MyCollection(Collection):
+    plugins=[(Drafts, ENABLE_DRAFTS)]
+    ...
+```
+
+### Using `Drafts` with `NextPrevPlugin` (or other, similar, `Collection` level plugins)
+
+Make sure that you register plugins in the order that you want them to run. Remember that
+any plugin that is registered with the `Site` prior to creating the `Collection` is included
+in the `Collection` the will have been registered first and will run _after_ plugins that
+are registered at the `Collection` level. Since plugins are invoked in the _reverse_ order
+of registration `Drafts` should be the last plugin run for a `Collection`.
+
+Example registration:
+
+```python
+import os
+from re_plugin_pack import Drafts, NextPrevPlugin
+from render_engine import Site, Collection
+
+ENABLE_DRAFTS = {"show_drafts": os.environ.get("SHOW_DRAFTS", False)}app=Site()
+
+@app.collection
+class MyCollection(Collection):
+    plugins = [
+        NextPrevPlugin,
+        (Drafts, ENABLE_DRAFTS),
+    ]
+```
+
+The above order will run the `Drafts` plugin first on that collection.
+
+### Marking a post as a `draft`
+
+To mark a post as a `draft` just add a truthy value for the `draft` attribute to the content:
+
+```
+---
+title: WIP Post
+date: 2025-06-01T02:49:18
+draft: Yes
+---
+This is a draft post
+```
+
+## `DateNormalizer`
+
+The goal of this plugin is to normalize entries in the `date` attribute of pages. This is necessary
+since valid entries include `datetime.date`, `datetime.datetime`, and date like strings. Since
+inconsistencies in the values of these fields can cause issues with sorting:
+
+```
+TypeError: '<' not supported between instances of 'datetime.datetime' and 'datetime.date'
+```
+
+and rendering if using the `format_datetime` function it is important that the date-like objects
+be normalized into `datetime.datetime` objects regardless of how they are set.
+
+### DateNormalizer Settings
+
+`DateNormalizer` has no settings.
+
+### Configuration
+
+`DateNormalizer` is a `Site` level plugins that runs prior to the site being rendered. It must
+be registered at the site level:
+
+```python
+from render_engine import Site, Page
+from re-plugin-pack import DateNormalizer
+
+app = Site()
+app.register_plugins(DateNormalizer)
+```

re_plugin_pack-2025.6.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+re_plugin_pack/__init__.py,sha256=f300e825fc8fae585c98a05a35e948abf24704169690005f76871a134adcdd8e,250
+re_plugin_pack/plugins/date_normalizer.py,sha256=c0b16878b4d8a87ee0cf005d9759768489f21e1e71d54f47b36761630ec1a60e,1431
+re_plugin_pack/plugins/drafts.py,sha256=0672e4642d88e7b0cda4774756e36850ff4398a57e30dfab63855b6945596960,774
+re_plugin_pack/plugins/latest_entries.py,sha256=9f0f4e75724a20c7c6217d19a5c1c0b14289ca5e3ddccfd85af9a4671df28713,5137
+re_plugin_pack/plugins/next_prev.py,sha256=feeb42c98c358dd186462174a4332228016de15840004066ff9815ef7a0d51db,2469
+re_plugin_pack-2025.6.1.dist-info/licenses/LICENSE.md,sha256=96b1a938d839ee7740846ef97e81bcced9ca178c8058dce405d2032484e48c41,1071
+re_plugin_pack-2025.6.1.dist-info/WHEEL,sha256=d9bfa3dfe8454c349f284c03d27f39943327e72f63576bb2a4481e7e394e6484,79
+re_plugin_pack-2025.6.1.dist-info/METADATA,sha256=d4f7651cf335a43c43138034c120f52775ed998c83464b7e9ddbdbd42b7a3489,12306
+re_plugin_pack-2025.6.1.dist-info/RECORD,,

re_plugin_pack-2025.6.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.7.15
+Root-Is-Purelib: true
+Tag: py3-none-any

re_plugin_pack-2025.6.1.dist-info/licenses/LICENSE.md

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