custom-combination 0.0.1__py3-none-any.whl

custom_combination/__init__.py

@@ -0,0 +1,13 @@
+__version__ = "0.0.1"
+
+from . import cli  # backward compat
+from .core import generate as _generate
+
+
+class CustomCombination:
+    @staticmethod
+    def generate(items, pick=None, min_picks=None, max_picks=None):
+        return _generate(items, pick, min_picks, max_picks)
+
+
+__all__ = ["CustomCombination", "cli", "__version__"]

custom_combination/cli.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+from typing import Annotated
+
+import typer
+
+from .core import generate as _core_generate
+
+app = typer.Typer()
+
+_SEPARATOR = ","
+
+
+@app.command()
+def generate(
+    items: Annotated[
+        str, typer.Option("--items", help="Comma-separated list, e.g. --items a,b,c")
+    ] = None,
+    min_picks: Annotated[
+        list[(str, int)],
+        typer.Option("--min-picks", "-minp", help="The items to be picked minimum e.g. -minp b,1"),
+    ] = None,
+    max_picks: Annotated[
+        list[(str, int)],
+        typer.Option("--max-picks", "-maxp", help="The items to be picked maximum e.g. -maxp b,1"),
+    ] = None,
+    pick: Annotated[
+        int,
+        typer.Option(
+            "--pick", "-p", "-n", help="The number of items to be picked, e.g. -p 3"
+        ),
+    ] = None,
+    out: Annotated[
+        str,
+        typer.Option(
+            "--out", "-o", help="Write results to a filepath, e.g. --out output.txt"
+        ),
+    ] = None,
+):
+
+    item_list = items.split(_SEPARATOR)
+
+    min_pick_list = [(item[0], int(item[1])) for item in [pick.split(_SEPARATOR) for pick in min_picks]]
+    max_pick_list = [(item[0], int(item[1])) for item in [pick.split(_SEPARATOR) for pick in max_picks]]
+
+    results = _core_generate(items=item_list, pick=pick, min_picks=min_pick_list, max_picks=max_pick_list)
+
+    if out:
+        with open(out, "w") as f:
+            f.write("\n".join([_SEPARATOR.join(perm) for perm in results]))
+    else:
+        for perm in results:
+            print(perm)
+
+    return results
+
+
+if __name__ == "__main__":
+    app()

custom_combination/core.py

@@ -0,0 +1,76 @@
+from collections import Counter
+from itertools import combinations
+
+
+def getDiff(list1, list2):
+    return [item1 for item1 in list1 if item1 not in list2]
+
+def does_exceed_max(combination_from_remaining, max_picked_list):
+    print(combination_from_remaining, max_picked_list)
+    combination_from_remaining_freq = Counter(combination_from_remaining)
+    max_pick_list_freq = Counter(max_picked_list)
+
+    for k, v in combination_from_remaining_freq.items():
+        if k in max_pick_list_freq and v > max_pick_list_freq[k]:
+            return True
+    
+    return False
+
+
+def get_result(rest_item_list, min_picked_list, max_picked_list, rest_n):
+
+    result = []
+    visited = {}
+
+    for combination_from_remaining in combinations(rest_item_list, rest_n):
+        if str(combination_from_remaining) not in visited and not does_exceed_max(combination_from_remaining, max_picked_list):
+            visited[str(combination_from_remaining)] = True
+            new_combination = min_picked_list[:]
+            new_combination.extend(combination_from_remaining)
+            new_combination.sort()
+            result.append(new_combination)
+
+    result.sort()
+
+    return result
+
+
+def extract_ignored_items(items):
+    ignoreList = []
+
+    if items:
+        for item in items:
+            if type(item) is tuple:
+                if not item[1]:
+                    ignoreList.append(item[0])
+
+    return ignoreList
+
+
+def extract_items(items):
+    item_list = []
+
+    if items:
+        for item in items:
+            if type(item) is str:
+                item_list.append(item)
+            elif type(item) is tuple:
+                item_list.extend([item[0]] * item[1])
+
+    return item_list
+
+
+def generate(items, pick=None, min_picks=None, max_picks=None):
+
+    item_list = extract_items(items)
+    min_picked_list = extract_items(min_picks)
+    max_picked_list = extract_items(max_picks)
+    pick_ignore_list = extract_ignored_items(max_picks)
+
+    rest_pick = pick - len(min_picked_list)
+
+    rest_item_list = getDiff(getDiff(item_list, min_picked_list), pick_ignore_list)
+
+    result = get_result(rest_item_list, min_picked_list, max_picked_list, rest_pick)
+
+    return result

custom_combination-0.0.1.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: custom-combination
+Version: 0.0.1
+Summary: A custom combination generator
+Project-URL: Homepage, https://github.com/yilmazhasan/custom_combination
+Project-URL: Issues, https://github.com/yilmazhasan/custom_combination/issues
+Author-email: Hasan YILMAZ <ylmzhsn@proton.me>, Reego Software <reego.software@gmail.com>
+License-File: LICENCE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# Custom Combination
+
+> Version 0.0.1
+
+Python implementation for Custom Combination.
+
+## Usage
+
+### Programmatic usage
+
+```py
+from custom_combination import CustomCombination
+
+CustomCombination.generate(
+    items=[("a", 1), ("b", 2), ("c", 3), "d"],
+    pick=3,
+    min_picks=[("b", 1), ("a", 0)],
+    max_picks=[("a", 0)])
+```
+
+### CLI usage
+
+```sh
+custom_combination --items "a,b,b,c,c,c,d" -pick 3 -minp "b,1" -maxp "a,0"
+```
+
+Output:
+
+```sh
+['b', 'c', 'd']
+['b', 'c', 'c']
+```
+
+## Set up locally for development
+
+1. Clone the repository
+
+   > `git clone git@github.com:yilmazhasan/custom_combination.git`
+
+2. Create and activate the virtural environment
+
+   > `python -m venv .venv`
+
+   > `source .venv/bin/activate`
+
+3. Install requirements:
+
+   > `pip install -r requirements.txt`
+
+4. Run the app:
+
+   > `python src/custom_combination/app.py --items a,b,c,d -pick a,0 -minp b,1 -max a,0`
+
+5. Test the app:
+
+   > `pytest`
+
+## Args Explained
+
+```sh
+--items "a,b,b,c,c,c,d" -pick 3 -min-picks b,1 -max-picks a,0
+```
+
+or shortly:
+
+```sh
+--items "a,b,b,c,c,c,d" -p 3 -minp b,1 -maxp a,0
+```
+
+This indicates that:
+
+- We have four items in the set `["a", "b", "c", "d"]` but with different frequencies.
+- Thus we have the list as `["a", "b", "b", "c", "c", "c", "d"]`
+
+- We want to generate combinations that have **3** items, which `-pick 3` specifies.
+
+- We want to pick at least:
+  - **1** occurrences of `"b"`
+
+- We want to pick at max:
+  - **0** occurrences of `"a"`
+
+This indicates the list to generate from is:
+
+`["b", "b", "c", "c", "c", "d"]` out of
+
+`["a", "b", "b", "c", "c", "c", "d"]` as `"a"` is excluded.
+
+Since `"b"` is to be included once, we need to select 2 more items from the list `["c", "c", "c", "d"]`, so we can select `["c", "c"]` or `["c", "d"]`
+
+Expected output:
+
+```sh
+[
+    ["b", "c", "c"],
+    ["b", "c", "d"]
+]
+```

custom_combination-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+custom_combination/__init__.py,sha256=0oSFbqAatnqE3QiG2w3ohRtGmhMQ2co2MVCR85g9Gls,329
+custom_combination/cli.py,sha256=uMfoUmfE5mYEA3NXWHr4wEiIL_sj5A0uSGBO4eV4mrs,1574
+custom_combination/core.py,sha256=JRdnC9BtCBsWxVLqIW6UCh0HHYyneLmwxUlXaqA77nA,2176
+custom_combination-0.0.1.dist-info/METADATA,sha256=A1_MN0O3MT-f80q4hmdX7YVQj3yZuOvJxWGeEAiQ8ps,2442
+custom_combination-0.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+custom_combination-0.0.1.dist-info/entry_points.txt,sha256=gPZRcLbjQpH8BTtR3aKoDEmZeYfhHj4n-Wr8qDa_I8Y,66
+custom_combination-0.0.1.dist-info/licenses/LICENCE,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+custom_combination-0.0.1.dist-info/RECORD,,

custom_combination-0.0.1.dist-info/WHEEL

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

custom_combination-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+custom_combination = custom_combination.cli:app

custom_combination-0.0.1.dist-info/licenses/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.