libreqda 1.2.0__py3-none-any.whl

taguette/templates/project_import_codebook_confirm.html

@@ -0,0 +1,49 @@
+{% extends "base.html" %}
+
+{% block title %}{% trans "page title" %}Import codebook{% endtrans %} | LibreQDA{% endblock %}
+
+{% block contents %}
+<h1>{% trans "title" %}Import a codebook{% endtrans %}</h1>
+<p>{% trans %}Use this form to import an existing codebook into your project. Existing tags will not be deleted, new tags will be added alongside them.{% endtrans %}</p>
+{% for error in errors %}
+<div class="alert alert-danger">{{ error }}</div>
+{% endfor %}
+<p>{% trans %}You are about to create the following tags:{% endtrans %}</p>
+<form action="{{ reverse_url('import_codebook', project.id) }}" method="post">
+    {{ xsrf_form_html() }}
+    {% for tag in tags %}
+    <div class="form-group row">
+        <div class="col-sm-2 form-check">
+            {% if tag.exists %}
+            <input type="checkbox" class="form-check-input" name="tag{{ loop.index0 }}-replace" id="tag{{ loop.index0 }}-replace" aria-label="Replace this tag"{% if tag.enabled %} checked{% endif %} />
+            <label for="tag{{ loop.index0 }}-replace">{% trans "codebook import tag option" %}Replace{% endtrans %}</label>
+            {% else %}
+            <input type="checkbox" class="form-check-input" name="tag{{ loop.index0 }}-import" id="tag{{ loop.index0 }}-import" aria-label="Replace this tag"{% if tag.enabled %} checked{% endif %} />
+            <label for="tag{{ loop.index0 }}-import">{% trans "codebook import tag option" %}Import{% endtrans %}</label>
+            {% endif %}
+        </div>
+        <div class="col-sm-3">
+            {% if tag.parent == '' %}
+            <input type="text" class="form-control" value="{{ tag.path }}" disabled/>
+            {% else %}
+            <input type="text" class="form-control" value="{{ tag.path }} -> {{ tag.parent }}" disabled/>
+            {% endif %}
+            <input type="hidden" name="tag{{ loop.index0 }}-path" value="{{ tag.path }}"/>
+            <input type="hidden" name="tag{{ loop.index0 }}-parent" value="{{ tag.parent }}"/>
+        </div>
+        <div class="col-sm-2">
+            <input type="color" class="form-control" name="tag{{ loop.index0 }}-color" value="{{ tag.color }}"/>
+        </div>
+        <div class="col-sm-5">
+            <input type="text" class="form-control" name="tag{{ loop.index0 }}-description" value="{{ tag.description }}" />
+        </div>
+    </div>
+    {% endfor %}
+    <div class="form-group row">
+        <div class="col-sm-10 offset-sm-2">
+            <input type="submit" class="btn btn-primary" value="{% trans "form submit button" %}Create tags{% endtrans %}" />
+            <a href="{{ reverse_url('project', project.id) }}" class="btn btn-secondary">{% trans "cancel button" %}Go back{% endtrans %}</a>
+        </div>
+    </div>
+</form>
+{% endblock %}

taguette/templates/project_new.html

@@ -0,0 +1,31 @@
+{% extends "base.html" %}
+
+{% block title %}{% trans "page title" %}New project{% endtrans %} | LibreQDA{% endblock %}
+
+{% block contents %}
+<p>{% trans "title" %}New project{% endtrans %}</p>
+{% if error %}
+<div class="alert alert-danger">{{ error }}</div>
+{% endif %}
+<form action="{{ reverse_url('new_project') }}" method="post">
+  {{ xsrf_form_html() }}
+  <div class="form-group row">
+    <label for="project-name" class="col-sm-2 col-form-label">{% trans "form label for new project name" %}Name{% endtrans %}</label>
+    <div class="col-sm-10">
+      <input type="text" class="form-control" id="project-name" name="name" value="{{ name }}" required />
+    </div>
+  </div>
+  <div class="form-group row">
+    <label for="project-description" class="col-sm-2 col-form-label">{% trans "form label for new project description" %}Description{% endtrans %}</label>
+    <div class="col-sm-10">
+      <textarea class="form-control" id="project-description" name="description">{{ description }}</textarea>
+    </div>
+  </div>
+  <div class="form-group row">
+    <div class="col-sm-10 offset-sm-2">
+      <button type="submit" class="btn btn-primary" data-test-id="save-project-button">{% trans "form submit button" %}Create{% endtrans %}</button>
+      <a href="{{ reverse_url('index') }}" class="btn btn-secondary ms-2">{% trans %}Cancel{% endtrans %}</a>
+    </div>
+  </div>
+</form>
+{% endblock %}

taguette/templates/tos.html

@@ -0,0 +1,8 @@
+{% extends "base.html" %}
+{% set active_page = "tos" %}
+
+{% block title %}{% trans "page title" %}Terms of Service{% endtrans %} | LibreQDA{% endblock %}
+
+{% block contents %}
+{{ tos_text }}
+{% endblock %}

taguette/templates/trans.js

@@ -0,0 +1,7 @@
+var lang = {{ language }};
+var catalog = {{ catalog }};
+
+window.gettext = function(message, args) {
+  var trans = catalog[message] || message;
+  return trans.replace(/%\(([^)]+)\)s/g, function(match, name) { return args[name]; });
+}

taguette/templates/welcome.html

@@ -0,0 +1,15 @@
+{% extends "base.html" %}
+{% set active_page = "index" %}
+
+{% block title %}{% trans "page title" %}Welcome{% endtrans %} | LibreQDA{% endblock %}
+
+{% block contents %}
+<div class="jumbotron">
+  <h1 class="display-3">{% trans "title" %}Welcome{% endtrans %}</h1>
+  <p class="lead">{% trans %}<span><a href="https://help.libreqda.org/">LibreQDA</a></span> is an open-source web-based document tagging tool for qualitative data analysis.{% endtrans %}</p>
+  <p>{% trans %}Using this tool, you can upload a collection of documents, create a hierarchy of codes, and annotate portions of documents with codes and notes that you can recall and organize later.{% endtrans %}</p>
+  {% if register_enabled %}
+  <p>{% trans url=reverse_url('register') %}<a href="{{ url }}">Register now</a> for free and get started!{% endtrans %}</p>
+  {% endif %}
+</div>
+{% endblock %}

taguette/utils.py

@@ -0,0 +1,177 @@
+import asyncio
+import logging
+import os
+import re
+import sentry_sdk
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+def _f(message):
+    """Pass-through translation function.
+
+    Marks a string for translation without translating it at run time.
+    """
+    return message
+
+
+class DefaultMap(object):
+    def __init__(self, default, mapping):
+        self.__default = default
+        self.mapping = mapping
+
+    def get(self, key):
+        try:
+            return self.mapping[key]
+        except KeyError:
+            return self.__default(key)
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+
+async def log_and_wait_proc(logger, proc):
+    while proc.returncode is None:
+        line = await proc.stdout.readline()
+        if not line:
+            break
+        line = line.decode('utf-8', 'replace')
+        if line[-1] == '\n':
+            line = line[:-1]
+        logger.info("%d: %s", proc.pid, line)
+
+    ret = await proc.wait()
+    lines = await proc.stdout.read()
+    for line in lines.splitlines():
+        line = line.decode('utf-8', 'replace')
+        logger.info("%d: %s", proc.pid, line)
+    return ret
+
+
+_windows_device_files = ('CON', 'AUX', 'COM1', 'COM2', 'COM3', 'COM4', 'LPT1',
+                         'LPT2', 'LPT3', 'PRN', 'NUL')
+_not_ascii_re = re.compile(r'[^A-Za-z0-9_.-]')
+_percent_escapes_re = re.compile(r'%[0-9A-Fa-f]{2}')
+
+
+def sanitize_filename(name):
+    """Sanitize a filename.
+
+    This takes a filename, for example provided by a browser with a file
+    upload, and turn it into something that is safe for opening.
+
+    Adapted from werkzeug's secure_filename(), copyright 2007 the Pallets team.
+    https://palletsprojects.com/p/werkzeug/
+    """
+    if not isinstance(name, str):
+        raise ValueError("File name is not a string")
+    if not name:
+        raise ValueError("File name cannot be empty")
+    name = _percent_escapes_re.sub('_', name)
+    if '/' in name:
+        name = name[name.rindex('/') + 1:]
+    if sanitize_filename.windows and '\\' in name:
+        # It seems that IE gets that wrong, at least when the file is from
+        # a network share
+        name = name[name.rindex('\\') + 1:]
+    name, ext = os.path.splitext(name)
+    name = name[:20]
+    ext = ext[:8]
+    name = _not_ascii_re.sub('', name).strip('._')
+    if not name:
+        name = '_'
+    ext = _not_ascii_re.sub('', ext)
+    if (
+        sanitize_filename.windows
+        and name.split('.')[0].upper() in _windows_device_files
+    ):
+        name = '_' + name
+    name = name + ext
+    return name
+
+
+sanitize_filename.windows = os.name == 'nt'
+
+_background_future_references = {}
+
+
+def background_task(task, *, should_never_exit=False):
+    future = asyncio.get_event_loop().create_task(task)
+    ident = id(future)
+
+    def callback(future):
+        _background_future_references.pop(ident, None)
+        try:
+            future.result()
+        except Exception as e:
+            sentry_sdk.capture_exception(e)
+            logger.exception("Exception in background task")
+        if should_never_exit:
+            logger.critical("Critical task died, exiting")
+            asyncio.get_event_loop().stop()
+            sys.exit(1)
+
+    future.add_done_callback(callback)
+
+    # Keep a strong reference to the future
+    # https://bugs.python.org/issue21163
+    _background_future_references[ident] = future
+
+
+def check_operator_consistency(paths):
+    has_and = '∩' in paths
+    has_or = '∪' in paths
+
+    if has_and and has_or:
+        return 'mixed'
+    elif has_and:
+        return 'and'
+    elif has_or:
+        return 'or'
+    else:
+        return 'or'
+
+
+def parse_paths_for_exclusion(paths):
+    import re
+    exclude_paths = []
+    include_paths = []
+    for path in re.findall(r'([∩∪¬]?[^\∩∪¬]+)', paths):
+        if path.startswith('¬'):
+            exclude_paths.append(path[1:])
+        else:
+            include_paths.append(path)
+    include_paths_string = ''.join(include_paths)
+    return exclude_paths, include_paths_string
+
+
+def get_path_informations(paths):
+    exclude_paths, include_paths_string = parse_paths_for_exclusion(paths)
+
+    operator_type = check_operator_consistency(paths)
+
+    list_of_paths = []
+
+    if operator_type == 'and':
+        list_of_paths = include_paths_string.split('∩')
+    elif operator_type == 'or':
+        list_of_paths = include_paths_string.split('∪')
+    elif operator_type == 'mixed':
+        list_of_paths = separate_and_group_tags(paths)
+
+    return list_of_paths, operator_type, exclude_paths
+
+
+def separate_and_group_tags(paths):
+
+    exclude_paths, include_paths_string = parse_paths_for_exclusion(paths)
+
+    or_groups = include_paths_string.split('∪')
+
+    grouped_tags = []
+    for group in or_groups:
+        and_tags = group.split('∩')
+        grouped_tags.append(and_tags)
+
+    return grouped_tags

taguette/validate.py

@@ -0,0 +1,141 @@
+import os
+import string
+
+from .utils import _f
+
+
+class InvalidFormat(ValueError):
+    """User-supplied value doesn't pass validation."""
+
+    def __init__(self, message):
+        super(InvalidFormat, self).__init__(message)
+        self.message = message
+
+
+def description(descr):
+    if not isinstance(descr, str):
+        raise ValueError("Description is not a string")
+    if len(descr) > 102400:
+        raise InvalidFormat(_f("Description is too long"))
+    return True
+
+
+def color(value):
+    if not isinstance(value, str):
+        raise ValueError("color is not a string")
+    return True
+
+
+def project_name(name):
+    if not name:
+        raise InvalidFormat(_f("Project name cannot be empty"))
+    if len(name) > 50:
+        raise InvalidFormat(_f("Project name is too long"))
+    return True
+
+
+ALLOWED_LOGIN_CHARACTERS_NEW = (
+    string.ascii_lowercase + string.digits +
+    '._-'
+)
+ALLOWED_LOGIN_CHARACTERS = (
+    ALLOWED_LOGIN_CHARACTERS_NEW + '+@ '
+)
+
+
+def fix_user_login(login, *, new=False):
+    login = login.lower()
+    user_login(login, new=new)
+    return login
+
+
+def user_login(login, *, new=False):
+    if not isinstance(login, str):
+        raise ValueError("Login is not a string")
+    if not login:
+        raise InvalidFormat(_f("User login cannot be empty"))
+    if len(login) > 255:
+        raise InvalidFormat(_f("User login is too long"))
+    if login != login.lower():
+        raise InvalidFormat(_f("User login is not lowercase"))
+    chars = ALLOWED_LOGIN_CHARACTERS_NEW if new else ALLOWED_LOGIN_CHARACTERS
+    if any(c not in chars for c in login):
+        raise InvalidFormat(_f("User login contains forbidden characters"))
+    return True
+
+
+def user_email(email):
+    if not isinstance(email, str):
+        raise ValueError("Email is not a string")
+    if not email:
+        raise InvalidFormat(_f("Email cannot be empty"))  # but it can be NULL
+    if '@' not in email:
+        raise InvalidFormat(_f("Invalid email address"))
+    if len(email) > 256:
+        raise InvalidFormat(_f("Email address is too long"))
+    return True
+
+
+def user_password(password):
+    if not isinstance(password, str):
+        raise ValueError("Password is not a string")
+    if len(password) < 5:
+        raise InvalidFormat(_f("Please use a longer password"))
+    if len(password) > 5120:
+        raise InvalidFormat(_f("Please use a shorter password"))
+    return True
+
+
+def document_name(name):
+    if not isinstance(name, str):
+        raise ValueError("Document name is not a string")
+    if not name:
+        raise InvalidFormat(_f("Document name cannot be empty"))
+    if len(name) > 50:
+        raise InvalidFormat(_f("Document name is too long"))
+    return True
+
+
+def tag_path(path):
+    if not isinstance(path, str):
+        raise ValueError("Tag path is not a string")
+    if not path:
+        raise InvalidFormat(_f("Tag path cannot be empty"))
+    if len(path) > 200:
+        raise InvalidFormat(_f("Tag path is too long"))
+    return True
+
+
+def filename(name):
+    if not isinstance(name, str):
+        raise ValueError("File name is not a string")
+    if not name:
+        raise ValueError("File name cannot be empty")
+    if len(name) > 100:
+        raise InvalidFormat(_f("File name is too long"))
+    if '\x00' in name:
+        raise InvalidFormat(_f("Invalid file name"))
+    return True
+
+
+def fix_filename(name):
+    if not isinstance(name, str):
+        raise ValueError("File name is not a string")
+    if not name:
+        raise ValueError("File name cannot be empty")
+    if '/' in name:
+        name = name[name.rindex('/') + 1:]
+    if fix_filename.windows and '\\' in name:
+        # It seems that IE gets that wrong, at least when the file is from
+        # a network share
+        name = name[name.rindex('\\') + 1:]
+    name, ext = os.path.splitext(name)
+    name = name[:50]
+    ext = ext[:8]
+    if not name:
+        name = '_'
+    name = name + ext
+    return name
+
+
+fix_filename.windows = os.name == 'nt'

taguette/version_check.py

@@ -0,0 +1,102 @@
+import json
+import logging
+import os
+import re
+import sys
+import time
+
+from tornado.httpclient import AsyncHTTPClient
+
+from . import __version__
+from .utils import background_task
+
+
+logger = logging.getLogger(__name__)
+
+
+GITLAB_TAGS_URL = (
+    'https://gitlab.com/api/v4/projects/'
+    'bin-cirst%2Flibreqda%2Flibre-qda/repository/tags'
+    '?per_page=20&order_by=updated&sort=desc'
+)
+CACHE_TTL = 6 * 3600
+
+_VERSION_RE = re.compile(r'(\d+(?:\.\d+)*)')
+
+_cache = {
+    'latest': None,
+    'checked_at': 0.0,
+    'in_flight': False,
+}
+
+
+def _parse(version):
+    match = _VERSION_RE.search(version or '')
+    if not match:
+        return ()
+    return tuple(int(x) for x in match.group(1).split('.'))
+
+
+def _is_newer(candidate, current):
+    try:
+        return _parse(candidate) > _parse(current)
+    except Exception:
+        return False
+
+
+async def _fetch_latest():
+    try:
+        client = AsyncHTTPClient()
+        response = await client.fetch(
+            GITLAB_TAGS_URL,
+            request_timeout=5,
+            connect_timeout=5,
+        )
+        data = json.loads(response.body)
+        if data and isinstance(data, list):
+            latest = None
+            latest_parsed = ()
+            for tag in data:
+                name = tag.get('name') or ''
+                parsed = _parse(name)
+                if parsed and parsed > latest_parsed:
+                    latest_parsed = parsed
+                    latest = name
+            if latest:
+                _cache['latest'] = latest
+                logger.info("Latest LibreQDA tag: %s", latest)
+    except Exception as e:
+        logger.warning("Version check failed: %s", e)
+    finally:
+        _cache['checked_at'] = time.time()
+        _cache['in_flight'] = False
+
+
+def is_desktop_bundle():
+    return getattr(sys, 'frozen', False)
+
+
+def get_outdated_version():
+    forced = os.environ.get('LIBREQDA_FORCE_OUTDATED_VERSION')
+    if forced:
+        return forced
+
+    if not is_desktop_bundle():
+        return None
+
+    now = time.time()
+    if (
+        not _cache['in_flight']
+        and now - _cache['checked_at'] > CACHE_TTL
+    ):
+        _cache['in_flight'] = True
+        try:
+            background_task(_fetch_latest())
+        except RuntimeError:
+            _cache['in_flight'] = False
+
+    latest = _cache['latest']
+    if latest and _is_newer(latest, __version__):
+        match = _VERSION_RE.search(latest)
+        return match.group(1) if match else latest
+    return None