tilingPuzzles 0.2.0__py3-none-any.whl

tilingpuzzles/games/tests/test_stone.py

@@ -0,0 +1,172 @@
+
+import sys
+sys.path.insert(0, '.')
+from tqdm import tqdm
+
+from tilingpuzzles.games.stone import Stone, Stone_Symetries
+from tilingpuzzles.games.tile import Tile
+from tilingpuzzles.logUtils.callGraph import GTracker
+from tilingpuzzles.games.komino import Komino
+from tilingpuzzles.visualize.visualize import Visualize
+
+from logging import info
+from time import sleep
+
+
+def test_stone():
+    n=10
+    A=set([(i//2,i) for i in range(10)])
+    s=Stone(A)
+    msk=s.to_mask(n,n)
+    
+    assert msk.any()
+    assert s==A
+    
+    s=Stone(((1,1),))
+    s2=s.shift(4,4)
+
+    assert s.bounding_Box == ((1,1),(1,1))
+    assert s.bounding_Box == ((1,1),(1,1))
+
+
+
+def test_boundary():
+
+    s=Stone(((0,0),))
+
+    assert s.outer_bound() == frozenset(((1,0),(-1,0),(0,1),(0,-1)))
+    assert s.inner_bound()==s
+
+
+
+def test_substones():
+    seed=Tile((0,0))
+    s=Stone((seed,))
+
+    for i in range(2):
+        s=Stone(s | s.outer_bound())
+        n=len(s)
+        subs=s.get_k_stone_on_tile(seed,n)
+        assert s == list(subs)[0]
+
+
+def test_normalize():
+    st=Stone(
+        [
+            (2,3),
+            (4,5),
+            (3,4),
+            (22,5)
+        ]
+    )
+
+    norm=st.normalize()
+    assert len(st) == len(norm)
+
+    for i in range(1,10):
+        norm2=st.shift(i,i).normalize()
+        assert norm==norm2
+        
+
+def test_symetries():
+    st=Stone([(0,0)])
+    get_symetries=Stone_Symetries()
+
+    sym=get_symetries(st)
+
+    assert len(sym)==1
+
+    st=Stone([(0,1),(0,0)])
+    sym=get_symetries(st)
+    assert len(sym)==2
+
+    st=Stone([(2,1),(1,1),(0,1),(0,0)])
+    sym=get_symetries(st)
+    assert len(sym)==8
+
+
+
+def test_clip_to_Bounds():
+    N=10
+    s=Stone(((i,i) for i in range(N)))
+
+    s2=s.clip_to_bounds(0,N,0,N)
+    assert s == s2 
+
+    for i in range(N):
+
+        s3=s.clip_to_bounds(0,i-1,0,i-1)
+        assert len(s3)==i
+
+
+def test_split_point():
+    # test if method finds the split point
+    sstring="""
+        #########################
+        ######splitpoint#########
+                    v
+        #########################
+        #########################
+    """
+    s:Stone=Stone.from_string(sstring)
+    #s.display()
+    split_tile= s.good_cut_point()
+    new_stone=Stone(s-{split_tile})
+    componets=new_stone.ConectedComponents()
+    assert len(componets)==2
+
+
+def test_split_point_random():
+    for i in tqdm(range(100)):
+        
+        k,_=Komino.generate(30,5)
+        s=k.T
+        assert s
+        assert s.isConected()
+        loop_runs=False
+        while(s and s.isConected()):
+            last_size=len(s)
+            p=s.good_cut_point(perc=0.5,offset=3)
+
+            match p:
+                case (int(), int()):
+                    pass
+                case _:
+                    assert False
+
+            s=Stone(s-{p})
+            assert len(s)==last_size -1
+            loop_runs=True
+        assert loop_runs
+    #return
+    #visual
+    # test spliting of random generated stones
+    for i in tqdm(range(10)):
+        
+        k,_=Komino.generate(100,5)
+        s=k.T
+        assert s
+        assert s.isConected()
+        loop_runs=False
+        vz=Visualize()
+        vz.add_stone(s)
+        while(s and s.isConected()):
+            last_size=len(s)
+            p=s.good_cut_point(perc=0.5,offset=3)
+            vz.add_stone(Stone({p}))
+            
+
+            match p:
+                case (int(), int()):
+                    pass
+                case _:
+                    assert False
+
+            s=Stone(s-{p})
+            assert len(s)==last_size -1
+            loop_runs=True
+        vz.render()
+        assert loop_runs
+        
+
+

tilingpuzzles/games/tests/test_tile.py

@@ -0,0 +1,19 @@
+
+from tilingpuzzles.games.tile import Tile
+import pytest
+
+def test_tile():
+
+    t=Tile((0,1))
+    n=t.get_neighbores()
+    assert len(n)==4, "this tile should have 4 neighbores"
+
+    # 3D
+    t=Tile((1,2,3))
+    n=t.get_neighbores()
+    assert len(n)==6, "3D => 6 faces"
+
+    # trap
+    t=Tile((0,0))
+    n=t.get_neighbores(lowerB=(0,0),upperB=(1,1))
+    assert len(n)==0, f"All blocked\n {n =}"

tilingpuzzles/games/tile.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+import logging
+
+#from .stone import Stone as Stone
+
+from . import stone
+
+
+
+class Tile(tuple):
+    #WARNING performance, remove this use plain tuples
+    
+    def __new__(cls,*cords):
+        cords=tuple(map(int,*cords))
+    
+        return super(Tile,cls).__new__(cls,cords)
+        
+    
+    def __init__(self,*cords):
+        pass
+
+    #TODO change to `stone.Stone.get_neigbores(tuple)-> Stone`
+    def get_neighbores(self,lowerB=None,upperB=None) -> stone.Stone:
+        res=[]
+        n=len(self)
+
+        for i in range(n):
+            new_cords=[ self[j]+ (i==j) for j in range(n)]
+            if upperB is None or new_cords[i]<upperB[i]:
+                res.append(Tile(new_cords))
+            new_cords=[ self[j]- (i==j) for j in range(n)]
+            if lowerB is None or new_cords[i]>=lowerB[i]:
+                res.append(Tile(new_cords))
+
+        return stone.Stone(res)
+    
+
+    
+

tilingpuzzles/logUtils/callGraph.py

@@ -0,0 +1,47 @@
+
+from graphviz import Digraph
+from functools import wraps
+
+
+
+class GTracker():
+
+    call_graph = Digraph(comment='Function Call Graph')
+
+    stk=["__main__"]
+
+    MAX_CNT=200
+    cnt=0
+
+
+    #@classmethod
+    def track_calls(func):
+        def wrapper(*args, **kwargs):
+            caller = GTracker.stk[-1]
+            callee = func.__name__ +f"\n{args =}\n {kwargs =}"
+            GTracker.stk.append(callee)
+
+            # Add nodes and edges to graph
+            GTracker.call_graph.node(caller)
+            GTracker.call_graph.node(callee)
+            GTracker.call_graph.edge(caller, callee)
+            #break after a certain number of iterations
+
+            GTracker.cnt+=1 
+            if GTracker.cnt>=GTracker.MAX_CNT:
+                GTracker.render()
+                assert False, 'Maximum number of tracked calls reached'
+            res= func(*args,**kwargs)
+            GTracker.stk.pop()
+            return res
+        return wrapper
+    
+    #@classmethod
+    def render():
+        GTracker.call_graph.render(view=True,engine='dot')
+
+    def clear():
+        GTracker.call_graph = Digraph(comment='Function Call Graph')
+
+        GTracker.stk=["__main__"]
+

tilingpuzzles/logger.py

@@ -0,0 +1,39 @@
+
+import logging
+
+class Logger():
+
+
+
+    def __init__(self,other):
+        self.LogOff=True
+        self.other=other
+        pass
+    
+    def WARN(self,*args,**kwargs):
+         if self.LogOff:
+             return
+         else:
+             msg,*args=args
+             logging.warning(f"obj {self.other} says:\n\t{msg}")
+         
+    def INFO(self,*args,**kwargs):
+         if self.LogOff:
+             return
+         else:
+             msg,*args=args
+             logging.INFO(f"obj {self.other} says:\n\t{msg}")
+    
+    def with_loging(f):
+        
+        def new_f(other,*args,**kwarsg):
+            other.LOG.OFF=False
+            res=f(other,*args,**kwarsg)
+            other.LOG.OFF=True
+            return res 
+        return  new_f
+            
+
+
+
+         

tilingpuzzles/solvers/hights.py

@@ -0,0 +1,3 @@
+
+# CPP backend on ints own should make this faster
+

tilingpuzzles/solvers/kominoSolver.py

@@ -0,0 +1,191 @@
+
+
+from ..games import komino
+from ..games import stone
+from logging import info
+from ..visualize import visualize
+from tqdm.notebook import tqdm
+
+
+class KominoSolverLimited():
+
+    def __init__(self,komino:komino.Komino,stoneDict:dict[stone.Stone,int]):
+        r"""
+        sets up a Solver
+         - komino
+            komino game
+         - stoneDict
+            dictionary of `stones` to `int`
+            how often a stone of a certain kind can be placed.
+        """
+
+        self.T = komino.T
+        self.stoneDict= stoneDict
+        k=None
+        for st in stoneDict:
+            k=len(st)
+            break
+        assert k
+        self.k=k 
+        self.solved = False 
+        self.solution: list[stone.Stone]=[ ]
+
+
+    def solve(self):
+        """
+        finds a solution fot the problem if one exists
+        """
+        stone.Stone_config.MaxCacheStoneSize=self.k
+        self.solved=self._get_solution(self.T,self.stoneDict)
+        return self.solution.copy()
+        pass
+
+    def _get_solution(self,T:stone.Stone,availableStones:dict[stone.Stone,int]) -> bool:
+        #info(f"{self.solution = }")
+        components=list(T.ConectedComponents())
+        components.sort(key=len)
+        expPoint=components[0].good_cut_point()
+        candidates =T.get_k_stone_on_tile(expPoint,self.k)
+
+        for candidate in candidates:
+            norm=candidate.normalize()
+            if norm not in availableStones:
+                continue
+            next_T=stone.Stone(T-candidate)
+            self.solution.append(candidate)
+            if not next_T:
+                return True
+
+            comp=next_T.ConectedComponents()
+            compSizesModK=map(lambda x:len(x) % self.k,comp)
+            allZero=all(size==0 for size in compSizesModK)
+            if not allZero:
+                self.solution.pop()
+                continue
+
+            next_dict=availableStones.copy()
+            next_dict[norm]-=1
+            if not next_dict[norm]:
+                del(next_dict[norm])
+            res=self._get_solution(next_T,next_dict)
+            if res:
+                return True
+            self.solution.pop()
+
+        return False
+    
+
+    def get_solution_viz(self):
+        """
+        visualization of the solution process
+        """
+        #WARNING outdatet
+        self.solved=self._get_solution_viz(self.T,self.stoneDict)
+        return self.solution.copy()
+        pass
+
+    def _get_solution_viz(self,T:stone.Stone,availableStones:dict[stone.Stone,int]) -> bool:
+        #info(f"{self.solution = }")
+
+        expPoint=T.getMinTile()
+        assert expPoint in T,f" {expPoint = } should be in T"
+        print(f"{expPoint = }")
+        print(f"{ availableStones = }")
+        candidates =T.get_k_stone_on_tile(expPoint,self.k)
+
+        print(f"{candidates = }")
+
+        vz = visualize.Visualize()
+
+        vz.add_stone(self.T)
+
+        for st in self.solution:
+            vz.add_stone(st)
+        vz.render()
+
+        for candidate in candidates:
+            norm=candidate.normalize()
+            if norm not in availableStones:
+                continue
+            next_T=stone.Stone(T-candidate)
+            self.solution.append(candidate)
+            if not next_T:
+                return True
+
+            comp=next_T.ConectedComponents()
+            compSizesModK=map(lambda x:len(x) % self.k,comp)
+            allZero=all(size==0 for size in compSizesModK)
+            if not allZero:
+                self.solution.pop()
+                continue
+
+            next_dict=availableStones.copy()
+            next_dict[norm]-=1
+            if not next_dict[norm]:
+                del(next_dict[norm])
+            res=self._get_solution_viz(next_T,next_dict)
+            if res:
+                return True
+            self.solution.pop()
+
+        return False
+
+
+    def count_solutions(self):
+        pass
+
+class KominoSolverUnlimted():
+
+    def __init__(self,kom:komino.Komino,k=5):
+        """
+        counts number of solutions if unlimited numbers of stones are given
+
+        uses Dynammic Programming 
+        """
+        #TODO
+        self.T = kom.T
+        self.k=kom.k
+        stone.Stone_config.MaxCacheStoneSize=self.k
+        self.DP={}
+
+    def solve(self,ProgressLevel=1,displayBelow=0) -> int:
+        #TODO
+        self.ProgressLevel=ProgressLevel
+        self.displayBelow=displayBelow
+        return self._solve(self.T)
+
+    def _solve(self,st:stone.Stone,curLevel=0):
+        #TODO
+        """
+        responsible for normalization
+        """
+        # Base Case
+        if not st:
+            return 1
+
+        st=st.normalize()
+        if st in self.DP:
+            return self.DP[st]
+        expPoint=st.good_cut_point()
+        candidates=st.get_k_stone_on_tile(expPoint,self.k)
+
+        if curLevel<self.ProgressLevel:
+            candidates=tqdm(candidates,desc=f"Level {curLevel}",position=curLevel,leave=(curLevel==0))
+        if curLevel<self.displayBelow:
+            st.display()
+        res=0
+        for candidate in candidates:
+            remainder=stone.Stone(st-candidate)
+            components=remainder.ConectedComponents()
+            compSizesModK=map(lambda x:len(x) % self.k,components)
+            allZero=all(mod==0 for mod in compSizesModK)
+            if not allZero:
+                continue
+            base=1
+            for component in components:
+                base*=self._solve(component,curLevel=curLevel+1)
+            res+=base
+        self.DP[st]=res
+        return res
+        pass
+

tilingpuzzles/solvers/tests/test_komino_solver.py

@@ -0,0 +1,30 @@
+
+from tilingpuzzles.games import komino as _komio
+from src.tilingpuzzles.solvers.kominoSolver import KominoSolverLimited
+from tilingpuzzles.games.stone import Stone
+
+from logging import info
+
+
+
+def test_KominoSolverLimited():
+    Komino=_komio.Komino
+
+    N=15
+
+    for k in range(2,6):
+        komino,stonesAllowed=Komino.generate(N,k)
+
+        solver=KominoSolverLimited(komino,stonesAllowed)
+        solution = solver.solve()
+        info(f"{solution = }")
+        assert solution
+
+        res=set()
+        for st in solver.solution:
+            res |= st
+        res = Stone(res)
+        assert res == komino.T
+
+def test_KominSolverUnlimited():
+    assert False, "not implementet test !"

tilingpuzzles/visualize/visualize.py

@@ -0,0 +1,61 @@
+
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.patches import Rectangle
+#from tilingPuzzles.games.stone import Stone
+import numpy as np
+
+class Visualize():
+
+    def __init__(self,figure=None,ax=None):
+        self.n =0
+        if ax is None:
+            ax=plt.subplot()
+            ax.set_aspect("equal")
+        
+        self.figure=figure
+        self.ax: Axes=ax
+        
+
+    def add_stone(self,stone,fill=None):
+        if fill is None:
+            fill=self.get_nth_color()
+        
+        for tile in stone:
+
+            rc=Rectangle(tile,1,1,edgecolor="black",facecolor=fill,lw=1.5)
+            self.ax.add_patch(rc)
+            self.ax.autoscale_view()
+
+    def update_stones(self,stones):
+        for stone in stones:
+            self.add_stone(stone=stone)
+
+    def get_nth_color(self,n=None):
+        if n is None:
+            n=self.n 
+            self.n+=1
+
+        pi=np.pi
+        sin=np.sin
+        shift=2
+        color=[ sin(shift*n+pi/4*i)**2 for i in range(3)  ]
+        s=sum(color)
+        color = [c/s for c in color]
+        color= "#"+"".join(f"{int(c*16**2):02x}" for c in color)
+        return color
+
+
+
+    def draw_stone(st):
+        st=st.shift_positive()
+        msk=st.to_mask()
+
+        plt.imshow(msk)
+        plt.show()
+
+        pass
+
+    def render(self):
+        plt.show()
+

tilingpuzzles-0.2.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: tilingPuzzles
+Version: 0.2.0
+Summary: Add your description here
+Author-email: jonathan graf <jonathangraf@outlook.de>
+Requires-Python: >=3.10
+Requires-Dist: billiard>=4.2.1
+Requires-Dist: graphviz>=0.20.3
+Requires-Dist: jupyter>=1.1.1
+Requires-Dist: matplotlib>=3.10.3
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: py-cpuinfo>=9.0.0
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: python-cpuid>=0.1.1
+Requires-Dist: scipy>=1.15.3
+Requires-Dist: timeout-decorator>=0.5.0
+Requires-Dist: tqdm>=4.67.1
+Description-Content-Type: text/markdown
+
+# TilingPuzzles
+
+## Requirements
+
+```bash
+pip install uv
+uv sync
+```
+
+## Test
+
+```bash
+pytest
+```
+
+## Build
+
+```bash
+uv build
+```
+
+# Demo
+
+[notebook](Demo.ipynb)

tilingpuzzles-0.2.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+tilingpuzzles/__init__.py,sha256=U5flfDCld7tYtZ9374eCWQ65UGLMndptYQkqw8xOuwM,56
+tilingpuzzles/logger.py,sha256=66fX7Tb8WkbOP-FqImiT2UXGGWyXnIw2gJT5IkGsWVA,771
+tilingpuzzles/benchmark/README.md,sha256=icAWDmRCJmdfuX4ps7HtHjR1QqvhYSeX9JQ4M2UwMB4,200
+tilingpuzzles/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/benchmark/git_state.py,sha256=IUp0IWOzlC_84JFrxlvl0DtP0l-U0QRzHCFrhLG1yMc,584
+tilingpuzzles/benchmark/run_benchmark.py,sha256=8PMpi0JOe1Vm9JYdByUBlaCbOagS3krmO4AebgfHX8E,2977
+tilingpuzzles/benchmark/data/timingResulsts.csv,sha256=A3cXQuqonxhDuZzJN1uSyJuIXJOrrLfOgTO-R8djBi0,42278
+tilingpuzzles/examples/README.md,sha256=vq6Qjppx96HhAnCpDm2U0298Wy7t-KQf6H1Or2sPmeQ,52
+tilingpuzzles/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/examples/rectangularPentomino.py,sha256=xpYQtmjMpF6XFL-oPYWVQRcOZqgWAR5xqQ6M9ajik_g,591
+tilingpuzzles/examples/scaledStones.py,sha256=qep-waU6_9TrA1zBjfRR9-Xsj9VcehScvEzhCqGFAC8,1876
+tilingpuzzles/examples/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/examples/tests/test_rectangularPentomino.py,sha256=gjYluiqrRGDMIVYY3OX8cQ5zvRpOJLGzgqjxX1ROBMk,406
+tilingpuzzles/examples/tests/test_scaledStones.py,sha256=vS1p6ErY-_SqjmNnU2uOsDP1FBA1Ki6bFM4894XbdR4,160
+tilingpuzzles/games/__init__.py,sha256=oH3fystDA1fw_Fz7grKfAqrZFPoz68aoRyewopgqSHM,32
+tilingpuzzles/games/game.py,sha256=C7KBYbJ41M0yCCaLfldlRoip7Us5dXeHTQPqc6AULlc,261
+tilingpuzzles/games/generic.py,sha256=fEDg3lTLXnQUbW0arxOyOz8TEneLaq9blN8VuKxER4s,57
+tilingpuzzles/games/komino.py,sha256=Cb-wk0u3pVe1gVq5eL8e2HPwjvt0PXFg4M9A2ERRghs,3771
+tilingpuzzles/games/realisations.py,sha256=C3ztLBuj23Ei0_isqteStIdSCS6e0kc2IMjYTqXU_iE,1714
+tilingpuzzles/games/stone.py,sha256=HQSGl5sO-AVuithElP0110q-sS-qq8VhnANOjCSi0Vs,14295
+tilingpuzzles/games/stone_core.py,sha256=naKrJERMthm21N6Yu_q65gBDFcisO_oEyU0ZCkmE664,642
+tilingpuzzles/games/tile.py,sha256=8-JqOOYybqR8SBDkT4SYPLYLYPf7j14KrqqeOJPxcEI,930
+tilingpuzzles/games/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/games/tests/test_game.py,sha256=6ngLGqjqdGs0KEgMX5gLfNOI3ll69Ax3EBmr1kkVoGg,95
+tilingpuzzles/games/tests/test_komino.py,sha256=E-K_gKANkbY-5u3PWbJe7NuR2_R6jpvTom5qsrMoavw,540
+tilingpuzzles/games/tests/test_realisations.py,sha256=mFbsUBhAetyjCuS5qAW3sO3iWkRiwPpMKjXCaX_TrBw,578
+tilingpuzzles/games/tests/test_stone.py,sha256=5p2KyWH-s_DprCmdBJSx9L6t2OLcRkf4NvGkS1u40a8,3600
+tilingpuzzles/games/tests/test_tile.py,sha256=9JgSLKbevFORNbPuR2tPko97rYy1PgVdbT3qhGUZNg8,395
+tilingpuzzles/logUtils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/logUtils/callGraph.py,sha256=g8tsEGL3MH4Alv1f1EUuv3jhPUj6KJ2eowoJEFbdC9M,1175
+tilingpuzzles/solvers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/solvers/hights.py,sha256=bCrBCvM_jwUmh7G5KjgIzzCy3Zjo2KRflW5fLDW_N40,52
+tilingpuzzles/solvers/kominoSolver.py,sha256=xfXAGGTsZ0K5TesDADmHuA4a8RyL-j_bcSQumBHyn6Y,5485
+tilingpuzzles/solvers/tests/test_komino_solver.py,sha256=IVDGm1lVmKwafNpSYQ6ja9s_K48MWdGbsGoOXumrlUQ,692
+tilingpuzzles/visualize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilingpuzzles/visualize/visualize.py,sha256=uuyi2FRvqujrphwfx0uz1UOQzpXgGCGyJSv_RQvQulI,1349
+tilingpuzzles-0.2.0.dist-info/METADATA,sha256=li40u-BrCmwSTwTwqcwlRQjzYRKoB8K2ZQl_5vAFeS8,750
+tilingpuzzles-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tilingpuzzles-0.2.0.dist-info/entry_points.txt,sha256=76zo3sy1IWctxF6HC3cMy1ANDDzewI-6eYeO1CTnyHU,53
+tilingpuzzles-0.2.0.dist-info/RECORD,,