igs-slm 0.1.5b3__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

slm/file_views/config.py

@@ -0,0 +1,253 @@
+import inspect
+import typing as t
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from django.urls import path
+from django.urls.resolvers import URLPattern
+from django.utils.module_loading import import_string
+
+from slm.defines import SiteLogFormat, SiteLogStatus
+
+
+@dataclass
+class Listing:
+    """
+    This is the interface for a file/directory listing that the template expects to render.
+    """
+
+    display: str
+    """
+    The name to display.
+    """
+
+    modified: t.Optional[datetime] = None
+    """
+    The last time this file or directory was modified.
+    """
+
+    size: t.Optional[int] = None
+    """
+    The size in bytes of the file if available.
+    """
+
+    is_dir: bool = False
+    """
+    True if this listing is a directory, False otherwise
+    """
+
+    on_disk: t.Optional[Path] = None
+    """
+    The path to the file or directory on disk.
+    """
+
+    def from_glob(
+        pattern: t.Optional[str], filter: t.Callable[[str], bool] = lambda _: True
+    ) -> t.Generator["Listing", None, None]:
+        """
+        Yield :class:`~slm.file_views.config.Listing` objects from a glob
+        pattern.
+
+        :param pattern: A glob pattern
+        :param filter: A callable that takes the name of the file or directory
+            and returns True if it should be included and False otherwise. Includes
+            everything by default.
+        :return: An iterable of :class:`~slm.file_views.config.Listing`
+            objects.
+        """
+        if pattern:
+            from glob import iglob
+
+            for path_str in iglob(pattern):
+                on_disk = Path(path_str)
+                stat = on_disk.stat()
+                if filter(on_disk.name):
+                    yield Listing(
+                        display=on_disk.name,
+                        modified=datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc),
+                        size=None if on_disk.is_dir() else stat.st_size,
+                        is_dir=on_disk.is_dir(),
+                        on_disk=on_disk,
+                    )
+
+
+@dataclass
+class Entry:
+    view: str
+    """
+    The import path to the view function or class.
+    """
+
+    download: t.Optional[bool] = None
+    """
+    If true, clicking on a file will download it, otherwise it will be opened in the browser
+    if it is a supported mime type.
+    """
+
+    name: t.Optional[str] = None
+    """
+    The name used to reverse the view. By default the name will be the path parts separated
+    by __
+    """
+
+    decorator: t.Optional[t.Callable[..., t.Any]] = None
+    """
+    A decorator to apply to the view. For example, to require login to access this
+    view set this to :func:`~django.contrib.auth.decorators.login_required`
+    """
+
+    options: t.Dict[str, t.Any] = field(default_factory=dict)
+    """
+    Extra kwargs to pass to path().
+    """
+
+    @abstractmethod
+    def urls(self, pth: Path, **kwargs) -> t.Sequence[URLPattern]: ...
+
+    def kwargs(self, **kwargs) -> t.Dict[str, t.Any]:
+        from django.conf import settings
+
+        return {
+            **self.options,
+            "download": self.download
+            if self.download is not None
+            else getattr(settings, "SLM_FILE_VIEW_DOWNLOAD", False),
+            **kwargs,
+        }
+
+    @property
+    def view_callback(self) -> t.Callable[..., t.Any]:
+        view = import_string(self.view)
+        view = view.as_view() if inspect.isclass(view) else view
+        if self.decorator:
+            return self.decorator(view)
+        return view
+
+    def view_name(self, pth: Path) -> str:
+        return self.name or self.path_str(pth).replace("/", "__")
+
+    @staticmethod
+    def path_str(pth: Path) -> str:
+        return f"{'/'.join(part for part in pth.parts if part != pth.root)}/"
+
+
+@dataclass
+class Directory(Entry):
+    order_key: t.Sequence[str] = ("is_dir", "display")
+
+    @abstractmethod
+    def urls(self, pth: Path, **kwargs) -> t.Sequence[URLPattern]: ...
+
+
+@dataclass
+class FileSystemDirectory(Directory):
+    view: str = "slm.file_views.views.FileSystemView"
+    glob: t.Optional[str] = None
+
+    def kwargs(self, **kwargs) -> t.Dict[str, t.Any]:
+        return {**super().kwargs(), "glob": self.glob, **kwargs}
+
+    def urls(self, pth: Path, **kwargs) -> t.Sequence[URLPattern]:
+        path_str = self.path_str(pth)
+        return (
+            path(
+                path_str,
+                self.view_callback,
+                kwargs=self.kwargs(**kwargs),
+                name=self.view_name(pth),
+            ),
+            path(
+                f"{path_str}<str:filename>",
+                self.view_callback,
+                kwargs=self.kwargs(**kwargs),
+                name=self.view_name(pth),
+            ),
+        )
+
+
+@dataclass
+class ArchivedSiteLogs(FileSystemDirectory):
+    view: str = "slm.file_views.views.ArchivedSiteLogView"
+
+    log_formats: t.Sequence[SiteLogFormat] = field(default_factory=list)
+    log_status: t.Sequence[SiteLogStatus] = field(
+        default_factory=SiteLogStatus.active_states
+    )
+    best_format: bool = False
+    most_recent: bool = False
+    non_current: bool = False
+
+    name_len: t.Optional[int] = None
+    lower_case: t.Optional[bool] = None
+
+    def kwargs(self, **kwargs) -> t.Dict[str, t.Any]:
+        return {
+            **super().kwargs(),
+            "log_formats": self.log_formats,
+            "log_status": self.log_status,
+            "best_format": self.best_format,
+            "most_recent": self.most_recent,
+            "non_current": self.non_current,
+            "name_len": self.name_len,
+            "lower_case": self.lower_case,
+            **kwargs,
+        }
+
+
+class File(Entry):
+    """
+    All file types must inherit from this class.
+    """
+
+    pass
+
+
+@dataclass
+class _Command:
+    command: str
+    """
+    The name of the management command that generates the file. This command
+    must write the file to standard out.
+    """
+
+    args: t.List[str] = field(default_factory=list)
+    """
+    CLI string arguments to pass to the command.
+    """
+
+
+@dataclass
+class GeneratedFile(File, _Command):
+    """
+    A view that generates a file from a management command.
+    """
+
+    view: str = "slm.file_views.views.command_output_view"
+    mimetype: t.Optional[str] = None
+    """
+    Give an explicit mime type for the generated file.
+    """
+
+    def path_str(self, pth: Path) -> str:
+        return super().path_str(pth).rstrip("/")
+
+    def kwargs(self, **kwargs) -> t.Dict[str, t.Any]:
+        return {
+            **super().kwargs(),
+            "command": self.command,
+            "mimetype": self.mimetype,
+            "args": self.args,
+            **kwargs,
+        }
+
+    def urls(self, pth: Path, **kwargs) -> t.Sequence[URLPattern]:
+        return (
+            path(
+                self.path_str(pth),
+                self.view_callback,
+                kwargs=self.kwargs(**kwargs),
+                name=self.view_name(pth),
+            ),
+        )

slm/file_views/settings.py

@@ -0,0 +1,124 @@
+from pathlib import Path
+
+from slm.defines import SiteLogFormat, SiteLogStatus
+from slm.file_views.config import ArchivedSiteLogs, GeneratedFile
+from slm.settings import env as settings_environment
+from slm.settings import get_setting
+
+env = settings_environment()
+
+SLM_SINEX_FILENAME = env(
+    "SLM_SINEX_FILENAME",
+    str,
+    default=get_setting(
+        "SLM_SINEX_FILENAME",
+        get_setting("SLM_ORG_NAME", "stations").lower().replace(" ", "_"),
+    ),
+)
+if SLM_SINEX_FILENAME and "." not in SLM_SINEX_FILENAME:
+    SLM_SINEX_FILENAME = f"{SLM_SINEX_FILENAME}.snx"
+
+SLM_FILE_VIEW_STRUCTURE = get_setting(
+    "SLM_FILE_VIEW_STRUCTURE",
+    [
+        (
+            "archive",
+            ArchivedSiteLogs(
+                order_key=("index__site__name", "timestamp"),
+                best_format=True,
+                non_current=True,
+            ),
+        ),
+        (
+            "current",
+            [
+                (
+                    "log",
+                    ArchivedSiteLogs(
+                        most_recent=True,
+                        best_format=True,
+                        log_formats={SiteLogFormat.LEGACY, SiteLogFormat.ASCII_9CHAR},
+                    ),
+                ),
+                (
+                    "xml",
+                    ArchivedSiteLogs(
+                        most_recent=True,
+                        best_format=True,
+                        log_formats={SiteLogFormat.GEODESY_ML},
+                    ),
+                ),
+            ],
+        ),
+        (
+            "former",
+            ArchivedSiteLogs(
+                best_format=True,
+                most_recent=True,
+                log_status=[SiteLogStatus.FORMER],
+                log_formats={SiteLogFormat.LEGACY, SiteLogFormat.ASCII_9CHAR},
+            ),
+        ),
+        (SLM_SINEX_FILENAME, GeneratedFile("generate_sinex", mimetype="text/plain"))
+        if SLM_SINEX_FILENAME
+        else None,
+    ],
+)
+
+# should clicking the file links in the file view download the file or open it in the browser?
+SLM_FILE_VIEW_DOWNLOAD = env(
+    "SLM_FILE_VIEW_DOWNLOAD", bool, default=get_setting("SLM_FILE_VIEW_DOWNLOAD", False)
+)
+
+SLM_FILE_VIEW_ROOT = Path(
+    env(
+        "SLM_FILE_VIEW_ROOT",
+        str,
+        default=get_setting("SLM_FILE_VIEW_ROOT", Path("files")),
+    )
+)
+
+
+BROWSER_RENDERABLE_MIMETYPES = get_setting(
+    "BROWSER_RENDERABLE_MIMETYPES",
+    {
+        "text/html",
+        "application/xhtml+xml",
+        "text/css",
+        "text/javascript",
+        "application/javascript",
+        "application/ecmascript",
+        "text/ecmascript",
+        "image/apng",
+        "image/avif",
+        "image/gif",
+        "image/jpeg",
+        "image/png",
+        "image/svg+xml",
+        "image/webp",
+        "image/bmp",
+        "image/x-icon",
+        "image/vnd.microsoft.icon",
+        "audio/midi",
+        "audio/x-midi",
+        "audio/mpeg",
+        "audio/ogg",
+        "audio/wav",
+        "audio/wave",
+        "audio/x-wav",
+        "audio/webm",
+        "audio/aac",
+        "video/mp4",
+        "video/mpeg",
+        "video/ogg",
+        "video/webm",
+        "video/x-msvideo",
+        "video/quicktime",
+        "application/xml",
+        "text/xml",
+        "application/rss+xml",
+        "application/atom+xml",
+        "application/pdf",
+        "text/plain",
+    },
+)

slm/file_views/static/slm/file_views/css/listing.css

@@ -0,0 +1,82 @@
+body {
+    font-family: 'Courier New', monospace;
+    margin: 20px;
+    background-color: #f8f9fa;
+}
+
+table {
+    width: 100%;
+    max-width: 768px;
+    border-collapse: collapse;
+    font-size: 14px;
+}
+
+th {
+    background-color: #f1f3f4;
+    padding: 8px 12px;
+    text-align: left;
+    border-bottom: 2px solid #ddd;
+    font-weight: normal;
+}
+
+td {
+    padding: 4px 12px;
+    border-bottom: 1px solid #eee;
+    vertical-align: top;
+}
+
+tr:hover {
+    background-color: #f8f9fa;
+}
+
+.name-column {
+    width: 55%;
+}
+
+.modified-column {
+    width: 30%;
+    white-space: nowrap;
+}
+
+.size-column {
+    width: 15%;
+    text-align: right;
+}
+
+.parent-directory {
+    font-weight: bold;
+}
+
+a {
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+.file-link {
+    text-decoration: none;
+    color: #1a73e8;
+}
+
+.file-link:hover {
+    text-decoration: underline;
+}
+
+.icon {
+    margin-right: 8px;
+    display: inline-block;
+    width: 16px;
+}
+#banner {
+    width: 768px;
+    margin-bottom: 5px;
+}
+
+#footer {
+    width: 768px;
+    height: 32px;
+    background-color: #5B98AF;
+    margin-top: 5px;
+}

slm/file_views/templates/slm/file_views/listing.html

@@ -0,0 +1,70 @@
+{% load static slm %}
+<html xmlns="http://www.w3.org/1999/xhtml">
+    {% block head %}
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+        <title>{{ title|default:"Directory Listing" }}</title>
+        <link href="{% static 'slm/file_views/css/listing.css' %}"
+              rel="stylesheet"
+              type="text/css">
+    </head>
+    {% endblock head %}
+    <body>
+        {% block banner %}
+        <img id="banner" src="{% static 'slm/file_views/banner_header.png' %}">
+        {% endblock banner %}
+        {% block listing %}
+        <div class="file-listing">
+            <table>
+                <thead>
+                    <tr>
+                        <th></th>
+                        <th class="name-column">
+                            <a href=".?C=N;O={{ N_ordering|default:'A' }}">Name</a>
+                        </th>
+                        <th class="modified-column">
+                            <a href=".?C=M;O={{ M_ordering|default:'A' }}">Last modified</a>
+                        </th>
+                        <th class="size-column">
+                            <a href=".?C=S;O={{ S_ordering|default:'A' }}">Size</a>
+                        </th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {% if parent %}
+                    <tr>
+                        <td class="icon-column">
+                            <span class="icon">↩️</span>
+                        </td>
+                        <td class="name-column">
+                            <a href="{{ parent }}" class="file-link parent-directory">Parent Directory</a>
+                        </td>
+                        <td class="modified-column">-</td>
+                        <td class="size-column">-</td>
+                    </tr>
+                    {% endif %}
+                    {% for listing in listings %}
+                    <tr>
+                        <td class="icon-column">
+                            <span class="icon">{% if listing.is_dir %}📁{% else %}📄{% endif %}</span>
+                        </td>
+                        <td class="name-column">
+                            <a href="{{listing.display}}{% if listing.is_dir %}/{% endif %}" {% if download and listing.is_dir %}download{% endif %}>{{listing.display}}</a>
+                        </td>
+                        <td class="modified-column">{{ listing.modified|simple_utc }}</td>
+                        <td class="size-column">{% if listing.size %}{% widthratio listing.size 1024 1 %}K{% else %}-{% endif %}</td>
+                    </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+    {% endblock listing %}
+    {% block footer %}
+    <div id="wrapper_bottom">
+        <div id="footer">
+            <div class="footer_nav"></div>
+        </div>
+    </div>
+    {% endblock footer %}
+</body>
+</html>

slm/file_views/urls.py

@@ -0,0 +1,47 @@
+import typing as t
+from pathlib import Path
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+from django.urls import path
+
+from .config import Entry, File, Listing
+from .views import FileSystemView
+
+SLM_INCLUDE = True
+
+app_name = "slm_file_views"
+
+urlpatterns = []
+
+Branch = t.Sequence[t.Union[t.Tuple[str, t.Union[Entry, "Branch"]]]]
+
+
+def add_paths(url_path: Path, entries: Branch):
+    listings = []
+    for entry in entries:
+        try:
+            pth, entries = entry
+        except (TypeError, ValueError) as err:
+            raise ImproperlyConfigured(
+                "Setting SLM_FILE_VIEW_STRUCTURE must contain sequences of (str, Entry) tuples."
+            ) from err
+        listings.append(Listing(pth, is_dir=not isinstance(entries, File)))
+        if isinstance(entries, Entry):
+            urlpatterns.extend(entries.urls(url_path / pth))
+        else:
+            add_paths(url_path / pth, entries)
+
+    urlpatterns.append(
+        path(
+            Entry.path_str(url_path),
+            FileSystemView.as_view(),
+            kwargs={"path": url_path, "listings": listings},
+        )
+    )
+
+
+add_paths(
+    Path("/") / getattr(settings, "SLM_FILE_VIEW_ROOT", {}),
+    (getattr(settings, "SLM_FILE_VIEW_STRUCTURE", []) or []),
+)