mittens 0.3.1 → 0.3.2

data/vendor/snowball/php/base-stemmer.php

@@ -0,0 +1,453 @@
+<?php
+abstract class SnowballStemmer {
+
+    protected string $current = '';
+    protected int $cursor = 0;
+    protected int $limit = 0;
+    protected int $limit_backward = 0;
+    protected int $bra = 0;
+    protected int $ket = 0;
+
+
+    abstract public function stem(): bool;
+
+
+    protected function copyFrom(self $other): void {
+        $this->current          = $other->current;
+        $this->cursor           = $other->cursor;
+        $this->limit            = $other->limit;
+        $this->limit_backward   = $other->limit_backward;
+        $this->bra              = $other->bra;
+        $this->ket              = $other->ket;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function in_grouping(array $s): bool {
+        if ($this->cursor >= $this->limit) {
+            return false;
+        }
+        $ch = $this->charAt();
+        if (!array_key_exists($ch, $s)) {
+            return false;
+        }
+        $this->cursor += strlen($ch);
+        return true;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function go_in_grouping(array $s): bool {
+        while ($this->cursor < $this->limit) {
+            $ch = $this->charAt();
+            if (!array_key_exists($ch, $s)) {
+                return true;
+            }
+            $this->cursor += strlen($ch);
+        }
+        return false;
+    }
+
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function in_grouping_b(array $s): bool {
+        if ($this->cursor <= $this->limit_backward) {
+            return false;
+        }
+        $ch = $this->charBefore();
+        if (!array_key_exists($ch, $s)) {
+            return false;
+        }
+        $this->cursor -= strlen($ch);
+        return true;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function go_in_grouping_b(array $s): bool {
+        while ($this->cursor > $this->limit_backward) {
+            $ch = $this->charBefore();
+            if (!array_key_exists($ch, $s)) {
+                return true;
+            }
+            $this->cursor -= strlen($ch);
+        }
+        return false;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function out_grouping(array $s): bool {
+        if ($this->cursor >= $this->limit) {
+            return false;
+        }
+        $ch = $this->charAt();
+        if (!array_key_exists($ch, $s)) {
+            $this->cursor += strlen($ch);
+            return true;
+        }
+        return false;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function go_out_grouping(array $s): bool {
+        while ($this->cursor < $this->limit) {
+            $ch = $this->charAt();
+            if (array_key_exists($ch, $s)) {
+                return true;
+            }
+            $this->cursor += strlen($ch);
+        }
+        return false;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function out_grouping_b(array $s): bool {
+        if ($this->cursor <= $this->limit_backward) {
+            return false;
+        }
+        $ch = $this->charBefore();
+        if (!array_key_exists($ch, $s)) {
+            $this->cursor -= strlen($ch);
+            return true;
+        }
+        return false;
+    }
+
+
+    /**
+     * @param int[] $s
+     */
+    protected function go_out_grouping_b(array $s): bool {
+        while ($this->cursor > $this->limit_backward) {
+            $ch = $this->charBefore();
+            if (array_key_exists($ch, $s)) {
+                return true;
+            }
+            $this->cursor -= strlen($ch);
+        }
+        return false;
+    }
+
+
+    protected function eq_s(string $s): bool {
+        $slength = strlen($s);
+        if ($this->limit - $this->cursor < $slength) {
+            return false;
+        }
+        if (substr_compare($this->current, $s, $this->cursor, $slength) != 0) {
+            return false;
+        }
+        $this->cursor += $slength;
+        return true;
+    }
+
+
+    protected function eq_s_b(string $s): bool {
+        $slength = strlen($s);
+        if ($this->cursor - $this->limit_backward < $slength) {
+            return false;
+        }
+        if (substr_compare($this->current, $s, $this->cursor - $slength, $slength) != 0) {
+            return false;
+        }
+        $this->cursor -= $slength;
+        return true;
+    }
+
+
+    /**
+     * @param array[] $v
+     */
+    protected function find_among(array $v): int {
+        $i = 0;
+        $j = count($v);
+
+        $c = $this->cursor;
+        $l = $this->limit;
+
+        $common_i = 0;
+        $common_j = 0;
+
+        $first_key_inspected = false;
+
+        while (true) {
+            $k = $i + (($j-$i) >> 1);
+            $diff = 0;
+            $common = min($common_i, $common_j); // smaller
+            // w[0]: string, w[1]: substring_i, w[2]: result, w[3]: function (optional)
+            $w = $v[$k];
+            $w0length = strlen($w[0]);
+            for ($i2 = $common; $i2 < $w0length; $i2++) {
+                if ($c + $common === $l) {
+                    $diff = -1;
+                    break;
+                }
+                $diff = strcmp($this->current[$c+$common], $w[0][$i2]);
+                if ($diff !== 0) {
+                    break;
+                }
+                $common++;
+            }
+            if ($diff < 0) {
+                $j = $k;
+                $common_j = $common;
+            }
+            else {
+                $i = $k;
+                $common_i = $common;
+            }
+            if ($j - $i <= 1) {
+                if ($i > 0) {
+                    break;
+                }
+                // v->s has been inspected
+                if ($j === $i) {
+                    break;
+                }
+                // only one item in v
+
+                // - but now we need to go round once more to get
+                // v->s inspected. This looks messy, but is actually
+                // the optimal approach.
+
+                if ($first_key_inspected) {
+                    break;
+                }
+                $first_key_inspected = true;
+            }
+        }
+        do {
+            $w = $v[$i];
+            $w0length = strlen($w[0]);
+            if ($common_i >= $w0length) {
+                $this->cursor = $c + $w0length;
+                if (count($w) < 4) {
+                    return $w[2];
+                }
+                $res = $this->{$w[3]}();
+                $this->cursor = $c + $w0length;
+                if ($res) {
+                    return $w[2];
+                }
+            }
+            $i = $w[1];
+        } while ($i >= 0);
+        return 0;
+    }
+
+
+    /**
+     * find_among_b is for backwards processing. Same comments apply
+     */
+    protected function find_among_b(array $v): int {
+        $i = 0;
+        $j = count($v);
+
+        $c = $this->cursor;
+        $lb = $this->limit_backward;
+
+        $common_i = 0;
+        $common_j = 0;
+
+        $first_key_inspected = false;
+
+        while (true) {
+            $k = $i + (($j-$i) >> 1);
+            $diff = 0;
+            $common = min($common_i, $common_j);
+            $w = $v[$k];
+            $w0length = strlen($w[0]);
+            for ($i2 = $w0length - 1 - $common; $i2 >= 0; $i2--) {
+                if ($c - $common == $lb) {
+                    $diff = -1;
+                    break;
+                }
+                $diff = strcmp($this->current[$c - 1 - $common], $w[0][$i2]);
+                if ($diff != 0) {
+                    break;
+                }
+                $common++;
+            }
+            if ($diff < 0) {
+                $j = $k;
+                $common_j = $common;
+            }
+            else {
+                $i = $k;
+                $common_i = $common;
+            }
+            if ($j - $i <= 1) {
+                if ($i > 0 || $j === $i || $first_key_inspected) {
+                    break;
+                }
+                $first_key_inspected = true;
+            }
+        }
+        do {
+            $w = $v[$i];
+            $w0length = strlen($w[0]);
+            if ($common_i >= $w0length) {
+                $this->cursor = $c - $w0length;
+                if (count($w) < 4) {
+                    return $w[2];
+                }
+                $res = $this->{$w[3]}();
+                $this->cursor = $c - $w0length;
+                if ($res) {
+                    return $w[2];
+                }
+            }
+            $i = $w[1];
+        } while ($i >= 0);
+        return 0;
+    }
+
+
+    /**
+     * to replace chars between $c_bra and $c_ket in $this->current by the chars in $s.
+     */
+    private function replace_s(int $c_bra, int $c_ket, string $s): int {
+        $slength = strlen($s);
+        $adjustment = $slength - ($c_ket - $c_bra);
+        $this->current = substr_replace($this->current, $s, $c_bra, $c_ket - $c_bra);
+        $this->limit += $adjustment;
+        if ($this->cursor >= $c_ket) {
+            $this->cursor += $adjustment;
+        } elseif ($this->cursor > $c_bra) {
+            $this->cursor = $c_bra;
+        }
+        return $adjustment;
+    }
+
+
+    private function slice_check(): void {
+        if (
+            $this->bra < 0 ||
+            $this->bra > $this->ket ||
+            $this->ket > $this->limit ||
+            $this->limit > strlen($this->current)
+        ) {
+            throw new LogicException('Faulty slice operation');
+        }
+    }
+
+
+    protected function slice_from(string $s): void {
+        $this->slice_check();
+        $this->replace_s($this->bra, $this->ket, $s);
+        $this->ket = $this->bra + strlen($s);
+    }
+
+
+    protected function slice_del(): void {
+        $this->slice_from('');
+    }
+
+
+    protected function insert(int $c_bra, int $c_ket, string $s): void {
+        $adjustment = $this->replace_s($c_bra, $c_ket, $s);
+        $c_bra <= $this->bra and $this->bra += $adjustment;
+        $c_bra <= $this->ket and $this->ket += $adjustment;
+    }
+
+
+    protected function slice_to(): string {
+        $this->slice_check();
+        return substr($this->current, $this->bra, $this->ket - $this->bra);
+    }
+
+    private function charAt(): string {
+        $s = $this->current[$this->cursor];
+        $c = ord($s);
+        if ($c < 0xc0) return $s;
+        if ($c < 0xe0) return substr($this->current, $this->cursor, 2);
+        if ($c < 0xf0) return substr($this->current, $this->cursor, 3);
+        return substr($this->current, $this->cursor, 4);
+    }
+
+    private function charBefore(): string {
+        $s = $this->current[$this->cursor - 1];
+        if (ord($s) < 0x80) return $s;
+        $o = $this->cursor - 1;
+        while (--$o && ord($this->current[$o]) < 0xc0) { }
+        return substr($this->current, $o, $this->cursor - $o);
+    }
+
+    protected function inc_cursor(): void {
+        do ++$this->cursor; while ($this->cursor < $this->limit && (ord($this->current[$this->cursor]) & 0xc0) == 0x80);
+    }
+
+    protected function dec_cursor(): void {
+        do --$this->cursor; while ($this->cursor > $this->limit_backward && (ord($this->current[$this->cursor]) & 0xc0) == 0x80);
+    }
+
+    protected function hop(int $delta): bool {
+        $res = $this->cursor;
+        while ($delta > 0) {
+            $delta--;
+            if ($res >= $this->limit) {
+                return false;
+            }
+            do {
+                $res++;
+            } while ($res < $this->limit && (ord($this->current[$res]) & 0xc0) == 0x80);
+        }
+        $this->cursor = $res;
+        return true;
+    }
+
+    protected function hop_checked(int $delta): bool {
+        return $delta >= 0 && $this->hop($delta);
+    }
+
+    protected function hop_back(int $delta): bool {
+        $res = $this->cursor;
+        while ($delta > 0) {
+            $delta--;
+            if ($res <= $this->limit_backward) {
+                return false;
+            }
+            do {
+                $res--;
+            } while ($res > $this->limit_backward && (ord($this->current[$res]) & 0xc0) == 0x80);
+        }
+        $this->cursor = $res;
+        return true;
+    }
+
+    protected function hop_back_checked(int $delta): bool {
+        return $delta >= 0 && $this->hop_back($delta);
+    }
+
+    /**
+     * Public entry point for stemming a word
+     */
+    public function stemWord(string $word): string {
+        $this->current = $word;
+        $this->cursor = 0;
+        $this->limit = strlen($word);
+        $this->limit_backward = 0;
+        $this->bra = $this->cursor;
+        $this->ket = $this->limit;
+        $this->stem();
+        return $this->current;
+    }
+}

data/vendor/snowball/php/stemwords.php

@@ -0,0 +1,25 @@
+<?php
+
+$lang = $argv[1] ?? 'english';
+$parent = realpath(__DIR__.'/..');
+$phpfile = $parent.'/php_out/'.$lang.'-stemmer.php';
+if (!file_exists($phpfile)) {
+    fwrite(STDERR, "PHP stemmer not found at $phpfile\n");
+    exit(1);
+}
+
+require __DIR__.'/base-stemmer.php';
+require $phpfile;
+
+$class = 'Snowball'.implode('', array_map('ucfirst', explode('_', $lang))).'Stemmer';
+if (!class_exists($class)) {
+    fwrite(STDERR, "$class not included from $phpfile\n");
+    exit(1);
+}
+$stemmer = new $class;
+
+while ($word = fgets(STDIN)) {
+    $word = strtolower(rtrim($word, "\n"));
+    $stem = $stemmer->stemWord($word);
+    echo $stem, "\n";
+}

data/vendor/snowball/python/create_init.py

@@ -16,8 +16,8 @@ for pyscript in os.listdir(python_out_folder):
     if (match):
         langname = match.group(1)
         titlecase = re.sub(r"_", "", langname.title())
-        languages.append("    '%(lang)s': %(title)sStemmer," % {'lang': langname, 'title': titlecase})
-        imports.append('from .%(lang)s_stemmer import %(title)sStemmer' % {'lang': langname, 'title': titlecase})
+        languages.append("        '%(lang)s': %(title)sStemmer," % {'lang': langname, 'title': titlecase})
+        imports.append('    from .%(lang)s_stemmer import %(title)sStemmer' % {'lang': langname, 'title': titlecase})
 imports.sort()
 languages.sort()
 
@@ -26,31 +26,26 @@ if len(languages) == 0:
 
 src = '''__all__ = ('language', 'stemmer')
 
-%(imports)s
-
-_languages = {
-%(languages)s
-}
-
 try:
     import Stemmer
-    cext_available = True
+    algorithms = Stemmer.algorithms
+    stemmer = Stemmer.Stemmer
 except ImportError:
-    cext_available = False
+%(imports)s
+
+    _languages = {
+%(languages)s
+    }
 
-def algorithms():
-    if cext_available:
-        return Stemmer.language()
-    else:
+    def algorithms():
         return list(_languages.keys())
 
-def stemmer(lang):
-    if cext_available:
-        return Stemmer.Stemmer(lang)
-    if lang.lower() in _languages:
-        return _languages[lang.lower()]()
-    else:
-        raise KeyError("Stemming algorithm '%%s' not found" %% lang)
+    def stemmer(lang):
+        lang = lang.lower()
+        if lang in _languages:
+            return _languages[lang]()
+        else:
+            raise KeyError("Stemming algorithm '%%s' not found" %% lang)
 ''' % {'imports': '\n'.join(imports), 'languages': '\n'.join(languages)}
 
 with open(os.path.join(python_out_folder, '__init__.py'), 'w') as out:

data/vendor/snowball/python/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

data/vendor/snowball/python/setup.py

@@ -3,7 +3,7 @@
 from setuptools import setup
 import re
 
-SNOWBALL_VERSION = '3.0.1'
+SNOWBALL_VERSION = '3.1.1'
 
 n_stemmers = 0
 
@@ -36,21 +36,18 @@ desc = 'This package provides ' + str(n_stemmers) + ' stemmers for ' + \
 classifiers = [
     'Development Status :: 5 - Production/Stable',
     'Intended Audience :: Developers',
-    'License :: OSI Approved :: BSD License'
 ]
 
 for lang in langs:
     lang_titlecase = lang.title()
     # Only classifiers listed in https://pypi.org/classifiers/ are allowed
     # Remove them here or submit them to https://github.com/pypa/trove-classifiers
-    classifiers.append('Natural Language :: ' + lang_titlecase)
+    if lang_titlecase != 'Sesotho':
+        classifiers.append('Natural Language :: ' + lang_titlecase)
 
 classifiers.extend([
     'Operating System :: OS Independent',
     'Programming Language :: Python',
-    'Programming Language :: Python :: 2',
-    'Programming Language :: Python :: 2.6',
-    'Programming Language :: Python :: 2.7',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3.3',
     'Programming Language :: Python :: 3.4',
@@ -63,6 +60,7 @@ classifiers.extend([
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
     'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3.14',
     'Programming Language :: Python :: Implementation :: CPython',
     'Programming Language :: Python :: Implementation :: PyPy',
     'Topic :: Database',
@@ -81,6 +79,6 @@ setup(name='snowballstemmer',
       license="BSD-3-Clause",
       packages=['snowballstemmer'],
       package_dir={"snowballstemmer": "src/snowballstemmer"},
-      python_requires='!=3.0.*, !=3.1.*, !=3.2.*',
+      python_requires='>=3.3',
       classifiers = classifiers
 )

data/vendor/snowball/python/snowballstemmer/among.py

@@ -1,5 +1,4 @@
-
-class Among(object):
+class Among:
     def __init__(self, s, substring_i, result, method=None):
         """
         @ivar s search string

data/vendor/snowball/python/snowballstemmer/basestemmer.py

@@ -1,4 +1,4 @@
-class BaseStemmer(object):
+class BaseStemmer:
     def __init__(self):
         self.set_current("")
 
@@ -88,20 +88,16 @@ class BaseStemmer(object):
         return False
 
     def eq_s(self, s):
-        if self.limit - self.cursor < len(s):
-            return False
-        if self.current[self.cursor:self.cursor + len(s)] != s:
-            return False
-        self.cursor += len(s)
-        return True
+        if self.current.startswith(s, self.cursor, self.limit):
+            self.cursor += len(s)
+            return True
+        return False
 
     def eq_s_b(self, s):
-        if self.cursor - self.limit_backward < len(s):
-            return False
-        if self.current[self.cursor - len(s):self.cursor] != s:
-            return False
-        self.cursor -= len(s)
-        return True
+        if self.current.endswith(s, self.limit_backward, self.cursor):
+            self.cursor -= len(s)
+            return True
+        return False
 
     def find_among(self, v):
         i = 0
@@ -151,9 +147,8 @@ class BaseStemmer(object):
                 self.cursor = c + len(w.s)
                 if w.method is None:
                     return w.result
-                res = w.method(self)
-                self.cursor = c + len(w.s)
-                if res:
+                if w.method(self):
+                    self.cursor = c + len(w.s)
                     return w.result
             i = w.substring_i
             if i < 0:
@@ -208,9 +203,8 @@ class BaseStemmer(object):
                 self.cursor = c - len(w.s)
                 if w.method is None:
                     return w.result
-                res = w.method(self)
-                self.cursor = c - len(w.s)
-                if res:
+                if w.method(self):
+                    self.cursor = c - len(w.s)
                     return w.result
             i = w.substring_i
             if i < 0:
@@ -235,20 +229,16 @@ class BaseStemmer(object):
             self.cursor = c_bra
         return adjustment
 
-    def slice_check(self):
-        if self.bra < 0 or self.bra > self.ket or self.ket > self.limit or self.limit > len(self.current):
-            return False
-        return True
-
     def slice_from(self, s):
         '''
         @type s string
         '''
-        result = False
-        if self.slice_check():
-            self.replace_s(self.bra, self.ket, s)
-            result = True
-        return result
+        assert self.bra >= 0
+        assert self.bra <= self.ket
+        assert self.ket <= self.limit
+        assert self.limit <= len(self.current)
+        self.replace_s(self.bra, self.ket, s)
+        self.ket = self.bra + len(s)
 
     def slice_del(self):
         return self.slice_from("")
@@ -269,10 +259,11 @@ class BaseStemmer(object):
         '''
         Return the slice as a string.
         '''
-        result = ''
-        if self.slice_check():
-            result = self.current[self.bra:self.ket]
-        return result
+        assert self.bra >= 0
+        assert self.bra <= self.ket
+        assert self.ket <= self.limit
+        assert self.limit <= len(self.current)
+        return self.current[self.bra:self.ket]
 
     def assign_to(self):
         '''