seqbuild 0.0.28__tar.gz → 0.0.30__tar.gz

{seqbuild-0.0.28 → seqbuild-0.0.30}/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Richard Pham
+Copyright (c) 2025-2026 Richard Pham
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{seqbuild-0.0.28 → seqbuild-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqbuild
-Version: 0.0.28
+Version: 0.0.30
 Summary: A collection of algorithms for pseudo-random number generation.
 Home-page: https://github.com/Changissnz/seqbuild
 Author: Richard Pham
@@ -48,8 +48,6 @@ for more details.
 
 # Third-Party Python Libraries 
 
-PIL>=9.0.0
-bs4>=4.10.0
 numpy>=1.22.1
 matplotlib>=3.5.3
 scipy>=1.14.1

{seqbuild-0.0.28 → seqbuild-0.0.30}/README.md

@@ -24,8 +24,6 @@ for more details.
 
 # Third-Party Python Libraries 
 
-PIL>=9.0.0
-bs4>=4.10.0
 numpy>=1.22.1
 matplotlib>=3.5.3
 scipy>=1.14.1

{seqbuild-0.0.28 → seqbuild-0.0.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "seqbuild"
-version = "0.0.28"
+version = "0.0.30"
 dependencies = [
 "numpy>=1.22.1",
 "matplotlib>=3.5.3",

{seqbuild-0.0.28 → seqbuild-0.0.30}/seqbuild/face/comm_lang.py

@@ -73,6 +73,7 @@ class CommLangParser:
 
     def reload_file(self,filepath:str): 
         self.fp = filepath 
+        self.finstat = False 
         self.preproc_file() 
 
     def close(self): 
@@ -100,7 +101,6 @@ class CommLangParser:
     def load_next_command(self):
         comm = "" 
         stat = True 
-
         while stat: 
             if self.file_obj.tell() != self.file_end:
                 line = self.file_obj.readline()
@@ -108,7 +108,6 @@ class CommLangParser:
             else: 
                 stat = False 
                 continue 
-
             line = line.strip() 
             if len(line) == 0: 
                 continue 

{seqbuild-0.0.28 → seqbuild-0.0.30}/seqbuild/seqgen/ssi_load.py

@@ -1,9 +1,9 @@
 from morebs2.search_space_iterator import * 
 from morebs2.matrix_methods import is_2dmatrix 
 
-from ..intigers.lcg_v3 import *  
-from ..intigers.prng_pw_op import * 
-from ..intigers.extraneous import * 
+from intigers.lcg_v3 import *  
+from intigers.prng_pw_op import * 
+from intigers.extraneous import * 
 
 SSIBL_STRUCTURES = ["lcg","mdr","mdrv2","optri"]
 
@@ -64,6 +64,35 @@ class OpTriGenLite:
         self.i = (self.i + 1) % (self.m.shape[0] * self.m.shape[1]) 
         return self.m[qi[0],qi[1]]
 
+"""
+(S)earch (S)pace (I)terator Net Node, Type (L)inear (C)ongruential (G)enerator Net 
+
+A unit node for the PRNG found in file<seqgen.ssi_netop>, which is itself a PRNG. It 
+uses one of four possible structure types: 
+(1) "lcg": linear congruential generator  
+(2) "mdr": modulo decomposition representation 
+(3) "mdrv2": modulo decomposition representation version 2 
+(4) "optri": operation triangle 
+---------------------------------------------------------------------------------------
+
+(1) simply directly outputs the LCG output. 
+    
+    /-/-/-/-/ 
+
+(2),(3), and (4) are activation-based, meaning that on a PRNG-scheduled basis, their 
+data structure `struct` is updated. 
+        NOTE: 
+In SeqBuild functionalities, this updating process is programmatically done by 
+the class<SSINetOp> PRNG. 
+
+The order of class methods to called when `sidn` is one of (2),(3), or (4) is: 
+- method<SSINetNode__TypeLCGNet.set_actsize> 
+- method<SSINetNode__TypeLCGNet.activate_base>
+
+Additionally, if `sidn` is of `mdr`|`mdrv2`, then an additional call to 
+method<SSINetNode__TypeLCGNet.load_first>, in order to calculate the next 
+number sequence from `struct`.
+""" 
 class SSINetNode__TypeLCGNet: 
 
     def __init__(self,structure_idn,prg,op_pair=None,exclude_neg=None,\
@@ -80,26 +109,28 @@ class SSINetNode__TypeLCGNet:
             assert len(op_pair) == 2 
         assert tmpcache_ratio >= 1.0 
 
+        # used for `optri`, `mdr` 
+        self.base_queue = [] 
+        self.base_activated = False 
+        self.tmp_queue = [] 
+        self.activation_size = None
+        self.termination_length = None 
+
         # used for `mdr` 
         self.exclude_neg = exclude_neg
         self.tmpcache_ratio = tmpcache_ratio
+        self.rvalues = [] 
 
         # used for `optri` 
         self.op_pair = op_pair 
 
-        # used for `optri`, `mdr` 
-        self.base_queue = [] 
-        self.base_activated = False 
-        self.tmp_queue = [] 
-
         self.struct = None 
-        # use for `mdr` `
-        self.rvalues = [] 
-
-        self.activation_size = None
-        self.termination_length = None 
 
+        # output counter, used in conjunction w/ `termination_length`. 
         self.c = 0 
+
+        # struct update counter 
+        self.uc = 0 
         return 
 
     def __next__(self):
@@ -117,12 +148,12 @@ class SSINetNode__TypeLCGNet:
                 q = self.rvalues.pop(0)
         else:
             q = next(self.struct)
-            
+        
         self.c += 1 
         return q 
 
     """
-
+    sets the `activation_size` class variable, which allows 
     """
     def set_actsize(self, activation_size): 
         assert "mdr" in self.sidn or "optri" in self.sidn
@@ -132,11 +163,16 @@ class SSINetNode__TypeLCGNet:
         self.activation_size = activation_size
         return
 
+    """
+    Updates the queues `tmp_queue` and `base_queue`. 
+    """
     def activate_base(self,aux_prg,verbose=0): 
         assert type(aux_prg) in {MethodType,FunctionType}
-        
+
         self.base_activated = True 
         x = self.tmp_queue[:self.activation_size]
+        #print("base {}, activation {}, tmp {}".format(len(self.base_queue),len(x),len(self.tmp_queue)))
+        #print("TQ: ",self.tmp_queue) 
         self.base_queue = x 
         self.tmp_queue = self.tmp_queue[self.activation_size:]
 
@@ -144,8 +180,14 @@ class SSINetNode__TypeLCGNet:
         if q == False:
             q = self.activate_optri(aux_prg,verbose) 
         self.struct = q 
+
+        self.uc += 1 
         return 
 
+    """
+    instantiates a new <ModuloDecomp> or <ModuloDecompV2> instance, 
+    using a modulated version of the number sequence `base_queue`. 
+    """ 
     def activate_mdr(self,aux_prg,verbose):    
         if "mdr" not in self.sidn: 
             return False 
@@ -154,15 +196,16 @@ class SSINetNode__TypeLCGNet:
 
         mdr = None
         if verbose: 
-            print("= activating {} w/ \n{}".format(self.sidn,BQ))
+            print("= activating {},act={},term={} w/ \n{}".format(self.sidn,self.activation_size,self.termination_length,BQ))
         
         if self.sidn == "mdr":
-            m = ModuloDecomp(IntSeq(BQ))
+            m = ModuloDecomp(IntSeq(BQ),max_absmult=112)
             m.merge(bool(self.exclude_neg)) 
             mdr = ModuloDecompRepr(m,1)
         else: 
-            m = ModuloDecomp(IntSeq(BQ),\
-                self.exclude_neg)
+            m = ModuloDecompV2(IntSeq(BQ),\
+                bool(self.exclude_neg),max_absmult=112) 
+            
             mdr = ModuloDecompRepr(m,2) 
 
         L = len(self.base_queue)
@@ -181,7 +224,8 @@ class SSINetNode__TypeLCGNet:
         self.termination_length = L_
 
         if verbose: 
-            print("= activating {} w/ \n{}".format(self.sidn,self.base_queue))
+            print("= activating {},act={},term={} w/ \n{}".format(self.sidn,self.activation_size,self.termination_length,\
+                self.base_queue))
 
         B = [npint32__mod__Q(b) for b in self.base_queue]
         iseq = IntSeq(B) 
@@ -206,10 +250,27 @@ class SSINetNode__TypeLCGNet:
         self.rvalues = self.struct.reconstruct()
         return
 
+"""
+Outputs a maximum of `max_batch_size` <SSINetNode__TypeLCGNet> instances, each of the 
+same structure type `structure_idn`. See variable<SSIBL_STRUCTURES> for a full view of 
+those structures. 
+
+This is a preliminary <SSINetNode__TypeLCGNet> generator, used by the generator 
+class<SSINetOp>. 
+
+The generation of <SSINetNode__TypeLCGNet> instances that are of structure type `lcg` 
+is via the output from a standard pass of a <SearchSpaceIterator> instance (a 4-dimensional 
+space represented by `param_bounds`), the four dimensions accounting for the four 
+parameter values that form an LCG (initial value, multiple, additive, modulo). 
+
+    NOTE: 
+The PRNG <SSINetOp> gets its name from this generation scheme concerning LCGs. 
+"""
 class SSIBatchLoader__TypeLCGNet: 
 
     """
     param_bounds := bounds vector (if structure is lcg) | ordered binary range (i.e. 00,01,10,11)
+    max_batch_size := int | inf 
     """
     def __init__(self,structure_idn,param_bounds,max_batch_size,aux_prg,ssi_hr=DEFAULT_SSINET_HOP_RANGE): 
         assert structure_idn in SSIBL_STRUCTURES
@@ -239,6 +300,7 @@ class SSIBatchLoader__TypeLCGNet:
             stat0 = is_bounds_vector(param_bounds)
             assert stat0 
             assert np.all(param_bounds[:,1] >= param_bounds[:,0]) 
+            assert len(param_bounds) == 4 
             self.param_bounds = param_bounds
 
         elif "mdr" in self.sidn:
@@ -303,17 +365,27 @@ class SSIBatchLoader__TypeLCGNet:
 
         return q,q1 
 
+"""
+A graph relation generator, used by class<SSINetOp> in its auto-generation method. 
+The relations are between elements of `structure_instances`, each a <SSINetNode__TypeLCGNet>. 
 
+Outputs relations into the map `h2tree_map`, a head-to-tree map. 
+"""
 class SSIBatch2Net:
 
     def __init__(self,structure_instances,num_trees,prg): 
         assert len(structure_instances) > 0 
-        assert type(num_trees) == int 
+        assert type(num_trees) == int and num_trees > 0 
         assert num_trees <= len(structure_instances) 
         assert type(prg) in {MethodType,FunctionType}
 
+        # each element is <SSINetNode__TypeLCGNet> 
         self.si = structure_instances
         self.num_trees = num_trees 
+
+        # `si` index -> Directed Tree 
+        # Directed Tree: source node        -> {target nodeset} 
+        #               `struct_list` index -> {`struct_list` indices}
         self.prg = prg 
         self.h2tree_map = dict()
         return 

{seqbuild-0.0.28 → seqbuild-0.0.30}/seqbuild/seqgen/ssi_netop.py

@@ -2,11 +2,74 @@ from .ssi_load import *
 from morebs2.numerical_generator import prg_partition_for_sz__n_rounds
 from morebs2.g2tdecomp import * 
 
-class SSINetOp:
+"""
+(S)earch (S)pace (I)terator Net Operator. 
+
+A pseudo-random number generator that relies in part on structure provided by 
+a search space iterator. 
+
+        *Instantiation Variables* 
+Set `io_prg` to a PRNG to add noise to pre-output values that are responsible 
+for the output values from <SSINetOp>. 
+
+Set `shuffle_dist` to 1 (active) for the <SSINetOp> to shuffle the numbers in 
+its reference queue Q, every time before using the shuffled numbers to update 
+the pertinent <SSINetNode__TypeLCGNet>s. 
+
+The reference queue Q is `tmp_queue` (contains numbers from all structure types 
+`lcg`,`mdr*`,`optri`) if `lcg_input_only` is set to 0. Otherwise, Q is `lcg_queue`. 
+
+        *Qualities* 
+
+In a typical instantiation via method<SSINetOp.one_instance>, <SSIBatchLoader__TypeLCGNet> 
+is used to generate at least five <SSINetNode__TypeLCGNet> instances. These instances contain 
+at least one of each of the following structure types: "lcg","mdr", and "optri". 
+
+Despite this PRNG getting its name from the <SearchSpaceIterator> used to generate LCGs, LCGs 
+are not required for this PRNG to output values. However, not using a significantly stochastic 
+quantity of LCGs, produced from the <SearchSpaceIterator> pass, would mean the <SSINetOp> 
+relies much more on its PRNG parameter `prg` to produce reference values for `mdr` and `optri` 
+<SSINetNode__TypeLCGNet> types. This basically translates to greater predictability of the 
+<SSINetOp> PRNG output, with knowledge of the `prg` output. 
+
+There are two classes of relations connecting the sequence `struct_list` of <SSINetNode__TypeLCGNet>s 
+together: 
+    - head node (tree identifier) -> directed node tree [`h2tree_map`]
+    - tree identifier -> {tree identifiers}. 
+
+These relations determine which <SSINetNode__TypeLCGNet>s get updated, through the course of source 
+trees being selected by <SSINetOp> to output values. 
+
+        *Basic Rundown* 
+<SSINetOp> starts by setting activation and termination sizes for every non-LCG node. 
+
+Every time <SSINetOp.__next__> is called, PRNG outputs the 0'th value from its primary queue, 
+`mainstream_queue`. 
+
+If `mainstream_queue` is empty, <SSINetOp> adds more numbers to queue by this procedure: 
+- <SSINetOp> clears its `tmp_queue`. 
+- It chooses one of its trees T. 
+- It iterates through each node n of T, and adds n's output to `tmp_queue`. 
+- For each of the neighboring trees T' connected to T, <SSINetOp> updates the `tmp_queue` 
+    of every node of `T'. See the section `*Instantiation Variables*` for the class 
+    variables involved in this update process. Also see method<<SSINetOp.distribute_to_connected_trees> 
+    and method<SSINetOp.distribute_seq_to_tree>. 
+- Additionally, each of these nodes may update their base `struct` by first passing values from their 
+  `tmp_queue`s to `base_queue`s, depending on if their counters pass their `activation_size` and 
+  `termination_length` parameters. 
+
+    NOTE: there are two primary types for updating: `rapid` and `slow`. See 
+    method<SSINetOp.update_node__type_*> for details on this update. 
+    This is specified by the class instantiation variable<rapid_update>. 
+
+    The `rapid` update type results in slower number generation. 
+
+""" 
+class SSINetOp: 
 
     def __init__(self,struct_list,h2tree_map,prg,\
         lcg_input_only=0,uniform_io_dist=1,shuffle_dist=0,\
-        io_prg=None,verbose:bool=False):
+        io_prg=None,rapid_update=False,verbose:bool=False):
 
         assert len(struct_list) > 3 
         assert len(h2tree_map) > 0
@@ -15,20 +78,27 @@ class SSINetOp:
         assert uniform_io_dist in {0,1}
         assert shuffle_dist in {0,1}
         assert type(io_prg) in {MethodType,FunctionType,type(None)}
+        assert type(rapid_update) == bool 
 
+        # each element is <SSINetNode__TypeLCGNet> 
         self.struct_list = struct_list
+        # `struct_list` index -> Directed Tree 
+        # Directed Tree: source node        -> {target nodeset} 
+        #               `struct_list` index -> {`struct_list` indices} 
         self.h2tree_map = h2tree_map
+        # key of `h2tree_map` -> {other keys of `h2tree_map`} 
         self.edges = dict()
         self.prg = prg 
         self.lcg_input_only = lcg_input_only 
         self.uniform_io_dist = uniform_io_dist 
         self.shuffle_dist = shuffle_dist
         self.io_prg = io_prg
-
+        self.rapid_update = rapid_update 
         self.verbose = verbose 
         
-        # storage of values from some source; values can be used for 
-        # the structures `mdr`,`mdrv2`,`optri`. 
+        # storage of values from some source <SSINetNode__TypeLCGNet>; 
+        # values can be used for the structures 
+        #       `mdr`,`mdrv2`,`optri`. 
         self.mainstream_queue = []
         self.prev_output = None 
 
@@ -42,6 +112,7 @@ class SSINetOp:
         self.prev = None  
 
         self.preprocess()
+        self.retry_counter = 3 
         return 
 
     ##-------------------------------------------------------------------
@@ -55,6 +126,9 @@ class SSINetOp:
         cx = combinations(ks,2)
         q = prg__single_to_int(self.prg)
 
+        for k in ks: 
+            self.edges[k] = set() 
+
         for c in cx: 
             d = int(round(q())) % 2 
             if d:
@@ -67,6 +141,10 @@ class SSINetOp:
                 self.edges[c[0]]|= {c[1]}
                 self.edges[c[1]]|= {c[0]}
 
+    """
+    sets activation and termination sizes for every <SSINetNode__TypeLCGNet> that 
+    is not of structure type `lcg`. 
+    """
     def set_actterm_sizes(self): 
         for q in self.struct_list: 
             if q.sidn == "lcg": 
@@ -79,7 +157,7 @@ class SSINetOp:
             r = modulo_in_range(self.prg(),\
                 DEFAULT_SSINETNODE__TYPE_FITTER_NUM_ITER) 
             q.termination_length = int(ceil(q.activation_size * r)) 
-            q.activate_base(self.prg)
+            q.activate_base(self.prg,True)
 
         return
 
@@ -87,6 +165,9 @@ class SSINetOp:
 
     def __next__(self): 
 
+        if self.retry_counter == 0: 
+            return 0 
+
         if len(self.mainstream_queue) > 0: 
             q = self.mainstream_queue.pop(0) 
             self.prev_output = q 
@@ -98,16 +179,26 @@ class SSINetOp:
         while len(self.mainstream_queue) == 0:
             H = self.choose_tree(exclude_trees)
             if self.verbose: print("- tree {}".format(H))
-            assert type(H) != type(None)
-            
+
+            # case: no trees produced any values, recursively 
+            #       call __next__ 
+            if type(H) == type(None): 
+                self.retry_counter -= 1 
+                return self.__next__() 
+
             self.process_tree(H) 
             exclude_trees |= {H} 
 
         q = self.mainstream_queue.pop(0)
         q = self.apply_noise(q) 
         self.prev_output = q 
+        self.retry_counter = 3 
         return q 
 
+    """
+    50/50 probability of modifying float `q` if `io_prg` is not 
+    null. 
+    """
     def apply_noise(self,q):
         if type(self.io_prg) == type(None): 
             return q 
@@ -133,8 +224,14 @@ class SSINetOp:
         # process value for each node 
         for k in K: 
             q = self.process_node(k) 
-            if type(q) != type(None): 
-                self.tmp_queue.append(q) 
+            if type(q) == type(None): 
+                continue 
+
+            if np.isnan(q) or np.isinf(q): 
+                continue 
+
+            self.tmp_queue.append(q) 
+
         if self.verbose: 
             print("\t+ procvec")
             print("\t{}".format(self.lcg_queue))
@@ -161,16 +258,33 @@ class SSINetOp:
                 if type(self.prev_output) != type(None): 
                     q.load_first(self.prev_output)
                     x = next(q)
-            if self.verbose: print("{} next: {}".format(q.sidn,x))
         else:
             x = next(q)
-            if self.verbose: print("{} next: {}".format(q.sidn,x))
+
+        if self.verbose and q.sidn != "lcg": print("{} next: {}, term={},c={},tmp_q={},base_q={}".\
+            format(q.sidn,x,q.termination_length,q.c,len(q.tmp_queue),len(q.base_queue)))
 
         # case: set new activation and termination length 
+        if self.rapid_update: 
+            F = self.update_node__type_rapid
+        else: 
+            F = self.update_node__type_slow
+
+        F(index)         
+
+        if type(x) != type(None): 
+            self.mo_queue.append(x)
+
+        return x 
+
+    def update_node__type_slow(self,index): 
+        q = self.struct_list[index] 
+
         if q.c >= q.termination_length:
-            if self.verbose: print("** updating {} @ index={}".format(q.sidn,index))
 
             q.activation_size = modulo_in_range(int(round(self.prg())),DEFAULT_BASE_QUEUE_ACTIVATION_RANGE) 
+            if self.verbose: print("** updating {} @ index={},act={}".format(q.sidn,index,q.activation_size))
+
             q.c = 0 
 
             #q.struct = None
@@ -181,14 +295,34 @@ class SSINetOp:
                 if self.verbose: print("\tbase update")
                 q.activate_base(self.prg,self.verbose)
 
-        if type(x) != type(None): 
-            self.mo_queue.append(x)
+    def update_node__type_rapid(self,index): 
+        q = self.struct_list[index] 
 
-        return x 
+        L = len(q.tmp_queue) 
+        if L >= q.activation_size:
+            if self.verbose: print("\tbase update")
+            q.activate_base(self.prg,self.verbose)
+
+        if q.c >= q.termination_length:
+
+            q.activation_size = modulo_in_range(int(round(self.prg())),DEFAULT_BASE_QUEUE_ACTIVATION_RANGE) 
+            if self.verbose: print("** updating {} @ index={},act={}".format(q.sidn,index,q.activation_size))
+
+            q.c = 0 
+
+            #q.struct = None
+            q.base_queue.clear()
+            q.base_activated = False
 
 
     #--------- network distribution of output values -----------------------------------
 
+    """
+    distributes reference vectors to every neighboring tree connected 
+    to `head`. Reference vectors are drawn from either the `lcg_queue` 
+    or `tmp_queue`. Each reference vector is appended to its associated 
+    node's `tmp_queue`.
+    """ 
     def distribute_to_connected_trees(self,head): 
         neighbors = self.edges[head]
 
@@ -208,16 +342,18 @@ class SSINetOp:
 
         def D(node): 
             L_ = [self.apply_noise(l) for l in L]
+
+            # case: uniform i/o, send entire sequence to node's tmp queue 
             if self.uniform_io_dist:
                 node.update_tmp_queue(deepcopy(L_))
                 return 
             
-            L_ = [] 
+            L2 = [] 
             prg_ = prg__single_to_int(self.prg)
-            for l in L: 
+            for l in L_: 
                 d = prg_() % 2 
-                if d: L_.append(l)
-            node.update_tmp_queue(deepcopy(L_))
+                if d: L2.append(l)
+            node.update_tmp_queue(deepcopy(L2)) 
 
         assert head in self.h2tree_map 
         T = self.h2tree_map[head] 
@@ -256,9 +392,12 @@ class SSINetOp:
 
     #-------------- instantiation ------------------------------------------------ 
 
+    def node_to_activation_count_map(self): 
+        return {i:n.uc for (i,n) in enumerate(self.struct_list)} 
+
     @staticmethod 
     def one_instance(num_nodes,prg,prg2,lcg_input_only=0,uniform_io_dist=1,shuffle_dist=0,\
-        prg_io_noise=0): 
+        prg_io_noise=0,rapid_update=True): 
         assert num_nodes >= 5 
         num_sets = 3 
         var = 0.25 
@@ -284,15 +423,15 @@ class SSINetOp:
         q2 = ssb2n.h2tree_map
         io_prg = prg if prg_io_noise else None
         return SSINetOp(q1,q2,prg2,lcg_input_only=lcg_input_only,\
-            uniform_io_dist=uniform_io_dist,shuffle_dist=shuffle_dist,io_prg=io_prg)
+            uniform_io_dist=uniform_io_dist,shuffle_dist=shuffle_dist,\
+            io_prg=io_prg,rapid_update=rapid_update)
 
     @staticmethod
     def one_instance__slist(sidn,batch_size,prg):
         # make an LCG from `prg` output 
         ix = [prg() for _ in range(4)] 
         ix = [modulo_in_range(ix_,[1.,101.]) for ix_ in ix]
-        prg2 = prg__LCG(ix[0],ix[1],ix[2],ix[3])
-
+        prg2 = prg__LCG(ix[0],ix[1],ix[2],ix[3])        
         if sidn == "lcg":
             prg3 = prg__single_to_bounds_outputter(prg,4) 
             param_bounds = prg3()

{seqbuild-0.0.28 → seqbuild-0.0.30}/seqbuild.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqbuild
-Version: 0.0.28
+Version: 0.0.30
 Summary: A collection of algorithms for pseudo-random number generation.
 Home-page: https://github.com/Changissnz/seqbuild
 Author: Richard Pham
@@ -48,8 +48,6 @@ for more details.
 
 # Third-Party Python Libraries 
 
-PIL>=9.0.0
-bs4>=4.10.0
 numpy>=1.22.1
 matplotlib>=3.5.3
 scipy>=1.14.1

{seqbuild-0.0.28 → seqbuild-0.0.30}/setup.py

@@ -5,7 +5,7 @@ with open('README.md') as f:
 
 setup(
     name='seqbuild',
-    version='0.0.28',
+    version='0.0.30',
     description='A collection of algorithms for pseudo-random number generation.',
     long_description=readme,
     author='Richard Pham',