custom-combination 0.0.1__tar.gz

custom_combination-0.0.1/.github/workflows/publish-to-pypi.yaml

@@ -0,0 +1,82 @@
+name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.x"
+
+      - name: Install pypa/build
+        run: >-
+          python3 -m
+          pip install
+          build
+          --user
+      - name: Build a binary wheel and a source tarball
+        run: python3 -m build
+      - name: Store the distribution packages
+        uses: actions/upload-artifact@v5
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/') # only publish to PyPI on tag pushes
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/custom_combination
+    permissions:
+      id-token: write # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v6
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+          skip-existing: true
+
+  publish-to-testpypi:
+    name: Publish Python 🐍 distribution 📦 to TestPyPI
+    needs:
+      - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/custom_combination
+
+    permissions:
+      id-token: write # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v6
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          verbose: true
+          skip-existing: true

custom_combination-0.0.1/.github/workflows/test-app.yaml

@@ -0,0 +1,32 @@
+name: Test Python package
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - development
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          cache: "pip"
+
+      - name: Install check deps
+        run: pip install ruff
+
+      - name: Lint check
+        run: ruff check
+
+      - name: Install test deps
+        run: pip install -r requirements.txt
+
+      - name: Test with pytest
+        run: pytest

custom_combination-0.0.1/.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.local

custom_combination-0.0.1/.python-version

@@ -0,0 +1 @@
+3.12

custom_combination-0.0.1/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.

custom_combination-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,98 @@
+# 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/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from custom-combination!")
+
+
+if __name__ == "__main__":
+    main()

custom_combination-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "custom-combination"
+dynamic = ["version"]
+dependencies = ["typer"]
+
+authors = [
+  { name="Hasan YILMAZ", email="ylmzhsn@proton.me" },
+  { name="Reego Software", email="reego.software@gmail.com" }
+]
+
+description = "A custom combination generator"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/yilmazhasan/custom_combination"
+Issues = "https://github.com/yilmazhasan/custom_combination/issues"
+
+[project.scripts]
+custom_combination = "custom_combination.cli:app"
+
+[tool.hatch.version]
+path = "src/custom_combination/__init__.py"
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

custom_combination-0.0.1/requirements.txt

@@ -0,0 +1,2 @@
+typer
+pytest

custom_combination-0.0.1/ruff.toml

@@ -0,0 +1,5 @@
+line-length = 88
+target-version = "py311"
+
+lint.select = ["E", "F", "I", "UP", "B"]
+lint.ignore = ["E501"] # Delegate line length to formatter   

custom_combination-0.0.1/src/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-0.0.1/src/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-0.0.1/src/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/tests/__init__.py

@@ -0,0 +1,3 @@
+import sys
+
+sys.path.insert(0, "src/custom_combination")

custom_combination-0.0.1/tests/test_app.py

@@ -0,0 +1,50 @@
+from custom_combination import CustomCombination
+
+
+def get_combination_count(combination_generator):
+    result = set()
+    for combination in combination_generator:
+        result.add(",".join(combination))
+    return len(result)
+
+
+def test_picks():
+    results = CustomCombination.generate(
+        items=["a", "a", "b", "b", "c", "c", "c", "d"],
+        pick=2
+    )
+
+    assert len(results) == 9
+
+
+def test_public_api():
+    results = CustomCombination.generate(
+        items=["a", "a", "b", "b", "c", "c", "c", "d"],
+        pick=3,
+        min_picks=["b"],
+        max_picks=[("a", 0)]
+    )
+
+    assert results == [["b", "c", "c"], ["b", "c", "d"]]
+
+
+def test_min_picks():
+    results = CustomCombination.generate(
+        items=["a", "a", "b", "b", "c", "c", "c", "d"],
+        pick=3,
+        min_picks=["b"]
+    )
+
+    assert results == [["a", "a", "b"], ["a", "b", "c"], ["a", "b", "d"], ["b", "c", "c"], ["b", "c", "d"]]
+
+def test_max_picks():
+    results = CustomCombination.generate(
+        items=["a", "a", "b", "b", "c", "c", "c", "d"],
+        pick=3,
+        max_picks=["c"]
+    )
+
+    assert results == [
+        ["a", "a", "b"], ["a", "a", "c"], ["a", "a", "d"], ["a", "b", "b"],
+        ["a", "b", "c"], ["a", "b", "d"], ["a", "c", "d"], ["b", "b", "c"],
+        ["b", "b", "d"], ["b", "c", "d"]]