make async and rename

Author: righ

.github/workflows/python.yaml

@@ -24,11 +24,12 @@ jobs:
           python -m pip install -r ci_requirements.txt
       - name: test
         run: |
-          pytest --cov=covertable
+          pytest --cov=covertable --cov-report=xml
       - name: codecov
         uses: codecov/codecov-action@v3
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+          file: ./coverage.xml
           verbose: true
 
   release:

python/.gitignore

@@ -3,9 +3,10 @@ __pycache__/
 .tox/
 venv/
 .coverage
+coverage.xml
 .junit.xml
 htmlcov/
 pip-wheel-metadata
 *.egg-info
 build/
-dist/
+dist/

python/covertable/criteria/greedy.py

@@ -3,19 +3,19 @@
 from itertools import combinations
 
 
-def get_num_removable_pairs(indexes, incompleted, length):
+def get_num_removable_pairs(indexes, incomplete, length):
     removing_keys = combinations(indexes, length)
-    return len(incompleted.intersection(removing_keys))
+    return len(incomplete.intersection(removing_keys))
 
 
 def extract(
-    sorted_incompleted, row, parents, length, incompleted, tolerance=0, **kwargs
+    sorted_incomplete, row, parents, length, incomplete, tolerance=0, **kwargs
 ):
     while True:
         max_num_pairs = None
         efficient_pair = None
 
-        for pair in sorted_incompleted:
+        for pair in sorted_incomplete:
             if not row:
                 yield pair
                 continue
@@ -31,7 +31,7 @@ def extract(
                 continue
 
             num_pairs = get_num_removable_pairs(
-                sorted({*row.values(), *pair}), incompleted, length
+                sorted({*row.values(), *pair}), incomplete, length
             )
             if num_pairs + tolerance > len(row) * storable:
                 efficient_pair = pair

python/covertable/criteria/simple.py

@@ -1,5 +1,5 @@
-def extract(sorted_incompleted, row, parents, **kwargs):
-    for pair in sorted_incompleted:
+def extract(sorted_incomplete, row, parents, **kwargs):
+    for pair in sorted_incomplete:
         storable = row.storable([(parents[p], p) for p in pair])
         if storable is None:
             continue

python/covertable/main.py

@@ -29,12 +29,12 @@ def convert_factors_to_serials(factors):
     return serials, parents
 
 
-def make_incompleted(serials, length):
-    incompleted = set()
+def make_incomplete(serials, length):
+    incomplete = set()
     for keys in combinations([k for k, _ in get_items(serials)], length):
         for pair in product(*[serials[keys[i]] for i in range(length)]):
-            incompleted.add(pair)
-    return incompleted
+            incomplete.add(pair)
+    return incomplete
 
 
 class Row(dict):
@@ -65,7 +65,7 @@ def storable(self, candidate=[]):
         if self.pre_filter is None:
             return num
         nxt = self.new({**self, **dict(candidate)})
-        if not self.pre_filter(nxt.restore()):
+        if not self.pre_filter(nxt.resolve()):
             return None
         return num
 
@@ -79,14 +79,21 @@ def complement(self):
             raise InvalidCondition(InvalidCondition.message)
         return self
 
-    def restore(self):
+    def resolve(self):
         return self.new(
             [key, self.factors[key][serial - self.serials[key][0]]]
             for key, serial in self.items()
         )
 
+    def restore(self):
+        resolved = self.resolve()
+        if issubclass(self.type, list):
+            return [r for _, r in sorted(resolved.items())]
+        if issubclass(self.type, dict):
+            return dict(resolved)
+
 
-def make(
+def make_async(
     factors,
     length=2,
     progress=False,
@@ -97,55 +104,70 @@ def make(
     **params,
 ):
     serials, parents = convert_factors_to_serials(factors)
-    incompleted = make_incompleted(serials, length)
-    len_incompleted = float(len(incompleted))
+    incomplete = make_incomplete(serials, length)
+    len_incomplete = float(len(incomplete))
     md5_cache = {}
 
-    rows, row = [], Row(None, factors, serials, pre_filter)
+    row = Row(None, factors, serials, pre_filter)
     # When pre_filter is specified,
-    # it will be applied to incompleted through `row.storable` beforehand.
-    for pair in list(filter(lambda _: pre_filter, incompleted)):
+    # it will be applied to incomplete through `row.storable` beforehand.
+    for pair in list(filter(lambda _: pre_filter, incomplete)): #########
         if not row.storable([(parents[p], p) for p in pair]):
-            incompleted.discard(pair)
+            incomplete.discard(pair)
 
-    while incompleted:
+    while incomplete:
         if row.filled():
-            rows.append(row)
+            if post_filter is None or post_filter(row.resolve()):
+                yield row.restore()
             row = row.new()
 
         common_kwargs = {
             **params,
             "row": row,
             "parents": parents,
             "length": length,
-            "incompleted": incompleted,
+            "incomplete": incomplete,
             "md5_cache": md5_cache,
         }
-        sorted_incompleted = sorter.sort(**common_kwargs)
-        for pair in criterion.extract(sorted_incompleted, **common_kwargs):
+        sorted_incomplete = sorter.sort(**common_kwargs)
+        for pair in criterion.extract(sorted_incomplete, **common_kwargs):
             if row.filled():
                 break
             row.update((parents[p], p) for p in pair)
             for vs in combinations(sorted(row.values()), length):
-                incompleted.discard(vs)
+                incomplete.discard(vs)
         else:
             if not row.filled():
                 row.complement()
 
         if progress:
-            rate = (len_incompleted - len(incompleted)) / len_incompleted
+            rate = (len_incomplete - len(incomplete)) / len_incomplete
             print("{0:.2%}\r".format(rate), end="")
 
     if row:
-        rows.append(row.complement())
-
-    result = []
-    for row in rows:
-        restored = row.restore()
-        if post_filter and not post_filter(restored):
-            continue
-        if issubclass(row.type, list):
-            result.append([r for _, r in sorted(restored.items())])
-        elif issubclass(row.type, dict):
-            result.append(dict(restored))
-    return result
+        row.complement()
+        if post_filter is None or post_filter(row.resolve()):
+            yield row.restore()
+
+
+def make(
+    factors,
+    length=2,
+    progress=False,
+    sorter=sorters.hash,
+    criterion=criteria.greedy,
+    pre_filter=None,
+    post_filter=None,
+    **params,
+):
+    gen = make_async(
+        factors,
+        length=length,
+        progress=progress,
+        sorter=sorter,
+        criterion=criterion,
+        pre_filter=pre_filter,
+        post_filter=post_filter,
+        **params,
+    )
+    return list(gen)

python/covertable/sorters/hash.py

@@ -4,7 +4,7 @@
 import hashlib
 
 
-def sort(incompleted, md5_cache, seed="", use_cache=True, *args, **kwargs):
+def sort(incomplete, md5_cache, seed="", use_cache=True, *args, **kwargs):
     def comparer(v):
         if use_cache and v in md5_cache:
             return md5_cache[v]
@@ -15,4 +15,4 @@ def comparer(v):
             md5_cache[v] = value
         return value
 
-    return sorted(incompleted, key=comparer)
+    return sorted(incomplete, key=comparer)

python/covertable/sorters/random.py

@@ -8,5 +8,5 @@ def random_comparer(_):
     return random.random()
 
 
-def sort(incompleted, *args, **kwargs):
-    return sorted(incompleted, key=random_comparer)
+def sort(incomplete, *args, **kwargs):
+    return sorted(incomplete, key=random_comparer)

typescript/src/criteria/greedy.ts

@@ -1,20 +1,20 @@
-import {CriterionArgsType, IncompletedType, PairType} from '../types';
+import {CriterionArgsType, IncompleteType, PairType} from '../types';
 import {getCandidate, combinations, ascOrder, unique} from '../utils';
 
-const getNumRemovablePairs = (indexes: Set<number>, incompleted: IncompletedType, length: number) => {
+const getNumRemovablePairs = (indexes: Set<number>, incomplete: IncompleteType, length: number) => {
   let num = 0;
   const removingKeys = combinations([... indexes], length);
   for (let pair of removingKeys) {
     const key = unique(pair);
-    if (incompleted.has(key)) {
+    if (incomplete.has(key)) {
       num++;
     }
   }
   return num;
 };
 
 export default function* (
-  incompleted: IncompletedType,
+  incomplete: IncompleteType,
   criterionArgs: CriterionArgsType,
 ): Generator<PairType> {
   let {row, parents, length, tolerance} = criterionArgs;
@@ -23,7 +23,7 @@ export default function* (
     let maxNumPairs: number | null = null;
     let efficientPair: PairType | null = null;
 
-    for (let [pairKey, pair] of incompleted.entries()) {
+    for (let [pairKey, pair] of incomplete.entries()) {
       const rowSize = row.size;
       if (rowSize === 0) {
         yield pair;
@@ -39,12 +39,12 @@ export default function* (
       }
 
       if (storable === 0) {
-        incompleted.delete(pairKey);
+        incomplete.delete(pairKey);
         continue;
       }
 
       const numPairs = getNumRemovablePairs(
-        new Set([... row.values(), ...pair]), incompleted, length
+        new Set([... row.values(), ...pair]), incomplete, length
       );
 
       if (numPairs + tolerance > rowSize * storable) {

typescript/src/criteria/simple.ts

@@ -1,12 +1,12 @@
-import {CriterionArgsType, IncompletedType, PairType} from '../types';
+import {CriterionArgsType, IncompleteType, PairType} from '../types';
 import {getCandidate} from '../utils';
 
 export default function* (
-  incompleted: IncompletedType,
+  incomplete: IncompleteType,
   criterionArgs: CriterionArgsType,
 ): Generator<PairType> {
   const {row, parents} = criterionArgs;
-  for (let pair of incompleted.values()) {
+  for (let pair of incomplete.values()) {
     const storable = row.storable(getCandidate(pair, parents));
     if (storable === null || storable === 0) {
       continue;

typescript/src/index.ts

@@ -19,7 +19,7 @@ import {
   MappingTypes,
   Scalar,
   Dict,
-  IncompletedType,
+  IncompleteType,
   ParentsType,
   CandidateType,
   RowType,
@@ -52,12 +52,12 @@ const serialize = (factors: FactorsType): MappingTypes => {
   return { serials, parents, indices };
 };
 
-const makeIncompleted = (
+const makeIncomplete = (
   mappings: MappingTypes,
   length: number,
   sorter: SorterType,
   seed: Scalar
-): IncompletedType => {
+): IncompleteType => {
   const { serials, indices } = mappings;
   const pairs: PairType[] = [];
   const allKeys = getItems(serials).map(([k, _]) => k);
@@ -68,11 +68,11 @@ const makeIncompleted = (
       pairs.push(pair);
     }
   }
-  const incompleted: IncompletedType = new Map();
+  const incomplete: IncompleteType = new Map();
   for (let pair of sorter(pairs, { seed, indices })) {
-    incompleted.set(unique(pair), pair);
+    incomplete.set(unique(pair), pair);
   }
-  return incompleted;
+  return incomplete;
 };
 
 class Row extends Map<Scalar, number> implements RowType {
@@ -183,24 +183,24 @@ const makeAsync = function* <T extends FactorsType>(
   const { preFilter, postFilter } = options;
   const mappings = serialize(factors);
   const { parents } = mappings;
-  const incompleted = makeIncompleted(mappings, length, sorter, seed); // {"1,2": [1,2], "3,4": [3,4]}
+  const incomplete = makeIncomplete(mappings, length, sorter, seed); // {"1,2": [1,2], "3,4": [3,4]}
 
   let row: Row = new Row([], mappings, factors, preFilter);
 
-  for (let [pairKey, pair] of incompleted.entries()) {
+  for (let [pairKey, pair] of incomplete.entries()) {
     if (!row.storable(getCandidate(pair, parents))) {
-      incompleted.delete(pairKey);
+      incomplete.delete(pairKey);
     }
   }
-  while (incompleted.size) {
+  while (incomplete.size) {
     if (row.filled()) {
       if (!postFilter || postFilter(row.toObject())) {
         yield row.restore() as SuggestRowType<T>;
       }
       row = row.New([]);
     }
     let finished = true;
-    for (let pair of criterion(incompleted, {
+    for (let pair of criterion(incomplete, {
       row,
       parents,
       length,
@@ -216,7 +216,7 @@ const makeAsync = function* <T extends FactorsType>(
       }
 
       for (let p of combinations([...row.values()], length)) {
-        incompleted.delete(unique(p));
+        incomplete.delete(unique(p));
       }
     }
     if (finished && !row.filled()) {