| Name | so4gp JSON |
| Version |
0.6.5
JSON |
| download |
| home_page | None |
| Summary | Some Python optimization algorithms for mining gradual patterns. |
| upload_time | 2024-11-13 10:04:59 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.9 |
| license | MIT License Copyright (c) 2021 Dickson Owuor (Ph.D.) 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. |
| keywords |
gradual patterns
graank
ant-colony-optimization
data-mining
swarm-intelligence
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
**SO4GP** stands for: "Some Optimizations for Gradual Patterns". SO4GP applies optimizations such as swarm intelligence, HDF5 chunks, cluster analysis and many others in order to improve the efficiency of extracting gradual patterns. It provides Python algorithm implementations for these optimization techniques. The algorithm implementations include:
* (Classical) GRAANK algorithm for extracting GPs
* Ant Colony Optimization algorithm for extracting GPs
* Genetic Algorithm for extracting GPs
* Particle Swarm Optimization algorithm for extracting GPs
* Random Search algorithm for extracting GPs
* Local Search algorithm for extracting GPs
* Clustering-based algorithm for extracting GPs
A GP (Gradual Pattern) is a set of gradual items (GI) and its quality is measured by its computed support value. For example given a data set with 3 columns (age, salary, cars) and 10 objects. A GP may take the form: {age+, salary-} with a support of 0.8. This implies that 8 out of 10 objects have the values of column age 'increasing' and column 'salary' decreasing.
## Install Requirements
Before running **so4gp**, make sure you install the following ```Python Packages```:
```shell
pip3 install numpy>=1.23.2 pandas>=1.4.4 python-dateutil>=2.8.2 ypstruct>=0.0.2 scikit-learn>=1.1.2
```
## Usage
In order to run each algorithm for the purpose of extracting GPs, follow the instructions that follow.
First and foremost, import the **so4gp** python package via:
```python
import so4gp as sgp
```
### 1. GRAdual rANKing Algorithm for GPs (GRAANK)
This is the classical approach (initially proposed by Anne Laurent) for mining gradual patterns. All the remaining algorithms are variants of this algorithm.
```python
mine_obj = sgp.GRAANK(data_source=f_path, min_sup=0.5, eq=False)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **eq** - *[optional]* encode equal values as gradual ```default = False```
### 2. Ant Colony Optimization for GPs (ACO-GRAANK)
In this approach, it is assumed that every column can be converted into gradual item (GI). If the GI is valid (i.e. its computed support is greater than the minimum support threshold) then it is either increasing or decreasing (+ or -), otherwise it is irrelevant (x). Therefore, a pheromone matrix is built using the number of columns and the possible variations (increasing, decreasing, irrelevant) or (+, -, x). The algorithm starts by randomly generating GP candidates using the pheromone matrix, each candidate is validated by confirming that its computed support is greater or equal to the minimum support threshold. The valid GPs are used to update the pheromone levels and better candidates are generated.
```python
mine_obj = sgp.AntGRAANK(data_src)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **max_iteration** - *[optional]* maximum number of iterations ```default = 1```
* **evaporation_factor** - *[optional]* evaporation factor ```default = 0.5```
### 3. Genetic Algorithm for GPs (GA-GRAANK)
In this approach, it is assumed that every GP candidate may be represented as a binary gene (or individual) that has a unique position and cost. The cost is derived from the computed support of that candidate, the higher the support value the lower the cost. The aim of the algorithm is search through a population of individuals (or candidates) and find those with the lowest cost as efficiently as possible.
```python
mine_obj = sgp.GeneticGRAANK(data_src)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```
* **n_pop** - *[optional]* initial population ```default = 5```
* **pc** - *[optional]* offspring population multiple ```default = 0.5```
* **gamma** - *[optional]* crossover rate ```default = 1```
* **mu** - *[optional]* mutation rate ```default = 0.9```
* **sigma** - *[optional]* mutation rate ```default = 0.9```
### 4. Particle Swarm Optimization for GPs (PSO-GRAANK)
In this approach, it is assumed that every GP candidate may be represented as a particle that has a unique position and fitness. The fitness is derived from the computed support of that candidate, the higher the support value the higher the fitness. The aim of the algorithm is search through a population of particles (or candidates) and find those with the highest fitness as efficiently as possible.
```python
mine_obj = sgp.ParticleGRAANK(data_src)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```
* **n_particles** - *[optional]* initial particle population ```default = 5```
* **velocity** - *[optional]* particle velocity ```default = 0.9```
* **coeff_p** - *[optional]* personal coefficient rate ```default = 0.01```
* **coeff_g** - *[optional]* global coefficient ```default = 0.9```
### 5. Local Search for GPs (LS-GRAANK)
In this approach, it is assumed that every GP candidate may be represented as a position that has a cost value associated with it. The cost is derived from the computed support of that candidate, the higher the support value the lower the cost. The aim of the algorithm is search through group of positions and find those with the lowest cost as efficiently as possible.
```python
mine_obj = sgp.HillClimbingGRAANK(data_src, min_sup)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```
* **step_size** - *[optional]* step size ```default = 0.5```
### 6. Random Search for GPs (RS-GRAANK)
In this approach, it is assumed that every GP candidate may be represented as a position that has a cost value associated with it. The cost is derived from the computed support of that candidate, the higher the support value the lower the cost. The aim of the algorithm is search through group of positions and find those with the lowest cost as efficiently as possible.
```python
import so4gp as sgp
mine_obj = sgp.RandomGRAANK(data_src, min_sup)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```
### 7. Clustering algorithm for GPs (Clu-BFS)
We borrow the net-win concept used in the work 'Clustering Using Pairwise Comparisons' proposed by R. Srikant to the problem of extracting gradual patterns (GPs). In order to mine for GPs, each feature yields 2 gradual items which we use to construct a bitmap matrix comparing each row to each other (i.e., (r1,r2), (r1,r3), (r1,r4), (r2,r3), (r2,r4), (r3,r4)).
In this approach, we convert the bitmap matrices into 'net-win vectors'. Finally, we apply spectral clustering to determine which gradual items belong to the same group based on the similarity of net-win vectors. Gradual items in the same cluster should have almost similar score vector.
```python
import so4gp as sgp
mine_obj = sgp.ClusterGP(data_source=data_src, min_sup=0.5, e_prob=0.1)
gp_json = mine_obj.discover()
print(gp_json)
```
where you specify the parameters as follows:
* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}
* **min_sup** - *[optional]* minimum support ```default = 0.5```
* **e_probability** - *[optional]* erasure probability ```default = 0.5```
* **max_iteration** - *[optional]* maximum iterations for estimating score vectors ```default = 10```
## Sample Output
The default output is the format of JSON:
```json
{
"Algorithm": "RS-GRAANK",
"Best Patterns": [
[["Age+", "Salary+"], 0.6],
[["Expenses-", "Age+", "Salary+"], 0.6]
],
"Iterations": 20
}
```
### References
* Owuor, D., Runkler T., Laurent A., Menya E., Orero J (2021), Ant Colony Optimization for Mining Gradual Patterns. International Journal of Machine Learning and Cybernetics. https://doi.org/10.1007/s13042-021-01390-w
* Dickson Owuor, Anne Laurent, and Joseph Orero (2019). Mining Fuzzy-temporal Gradual Patterns. In the proceedings of the 2019 IEEE International Conference on Fuzzy Systems (FuzzIEEE). IEEE. https://doi.org/10.1109/FUZZ-IEEE.2019.8858883.
* Laurent A., Lesot MJ., Rifqi M. (2009) GRAANK: Exploiting Rank Correlations for Extracting Gradual Itemsets. In: Andreasen T., Yager R.R., Bulskov H., Christiansen H., Larsen H.L. (eds) Flexible Query Answering Systems. FQAS 2009. Lecture Notes in Computer Science, vol 5822. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-04957-6_33
Raw data
{
"_id": null,
"home_page": null,
"name": "so4gp",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.9",
"maintainer_email": "Dickson Owuor <owuordickson@gmail.com>",
"keywords": "gradual patterns, GRAANK, ant-colony-optimization, data-mining, swarm-intelligence",
"author": null,
"author_email": "Dickson Owuor <owuordickson@gmail.com>, Anne Laurent <laurent@lirmm.fr>",
"download_url": "https://files.pythonhosted.org/packages/d7/61/ebf68166a0de4f8d4c2549cb6048dfcbca9df9f9d271c83717fc639a58dd/so4gp-0.6.5.tar.gz",
"platform": null,
"description": "\r\n**SO4GP** stands for: \"Some Optimizations for Gradual Patterns\". SO4GP applies optimizations such as swarm intelligence, HDF5 chunks, cluster analysis and many others in order to improve the efficiency of extracting gradual patterns. It provides Python algorithm implementations for these optimization techniques. The algorithm implementations include:\r\n\r\n* (Classical) GRAANK algorithm for extracting GPs\r\n* Ant Colony Optimization algorithm for extracting GPs\r\n* Genetic Algorithm for extracting GPs\r\n* Particle Swarm Optimization algorithm for extracting GPs\r\n* Random Search algorithm for extracting GPs\r\n* Local Search algorithm for extracting GPs\r\n* Clustering-based algorithm for extracting GPs\r\n\r\nA GP (Gradual Pattern) is a set of gradual items (GI) and its quality is measured by its computed support value. For example given a data set with 3 columns (age, salary, cars) and 10 objects. A GP may take the form: {age+, salary-} with a support of 0.8. This implies that 8 out of 10 objects have the values of column age 'increasing' and column 'salary' decreasing.\r\n\r\n## Install Requirements\r\nBefore running **so4gp**, make sure you install the following ```Python Packages```:\r\n\r\n```shell\r\npip3 install numpy>=1.23.2 pandas>=1.4.4 python-dateutil>=2.8.2 ypstruct>=0.0.2 scikit-learn>=1.1.2\r\n```\r\n\r\n## Usage\r\nIn order to run each algorithm for the purpose of extracting GPs, follow the instructions that follow.\r\n\r\nFirst and foremost, import the **so4gp** python package via:\r\n\r\n```python\r\nimport so4gp as sgp\r\n```\r\n\r\n### 1. GRAdual rANKing Algorithm for GPs (GRAANK)\r\n\r\nThis is the classical approach (initially proposed by Anne Laurent) for mining gradual patterns. All the remaining algorithms are variants of this algorithm.\r\n\r\n```python\r\n\r\nmine_obj = sgp.GRAANK(data_source=f_path, min_sup=0.5, eq=False)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **eq** - *[optional]* encode equal values as gradual ```default = False```\r\n\r\n\r\n### 2. Ant Colony Optimization for GPs (ACO-GRAANK)\r\nIn this approach, it is assumed that every column can be converted into gradual item (GI). If the GI is valid (i.e. its computed support is greater than the minimum support threshold) then it is either increasing or decreasing (+ or -), otherwise it is irrelevant (x). Therefore, a pheromone matrix is built using the number of columns and the possible variations (increasing, decreasing, irrelevant) or (+, -, x). The algorithm starts by randomly generating GP candidates using the pheromone matrix, each candidate is validated by confirming that its computed support is greater or equal to the minimum support threshold. The valid GPs are used to update the pheromone levels and better candidates are generated.\r\n\r\n```python\r\n\r\nmine_obj = sgp.AntGRAANK(data_src)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **max_iteration** - *[optional]* maximum number of iterations ```default = 1```\r\n* **evaporation_factor** - *[optional]* evaporation factor ```default = 0.5```\r\n\r\n\r\n### 3. Genetic Algorithm for GPs (GA-GRAANK)\r\nIn this approach, it is assumed that every GP candidate may be represented as a binary gene (or individual) that has a unique position and cost. The cost is derived from the computed support of that candidate, the higher the support value the lower the cost. The aim of the algorithm is search through a population of individuals (or candidates) and find those with the lowest cost as efficiently as possible.\r\n\r\n```python\r\n\r\nmine_obj = sgp.GeneticGRAANK(data_src)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```\r\n* **n_pop** - *[optional]* initial population ```default = 5```\r\n* **pc** - *[optional]* offspring population multiple ```default = 0.5```\r\n* **gamma** - *[optional]* crossover rate ```default = 1```\r\n* **mu** - *[optional]* mutation rate ```default = 0.9```\r\n* **sigma** - *[optional]* mutation rate ```default = 0.9```\r\n\r\n### 4. Particle Swarm Optimization for GPs (PSO-GRAANK)\r\nIn this approach, it is assumed that every GP candidate may be represented as a particle that has a unique position and fitness. The fitness is derived from the computed support of that candidate, the higher the support value the higher the fitness. The aim of the algorithm is search through a population of particles (or candidates) and find those with the highest fitness as efficiently as possible.\r\n\r\n```python\r\n\r\nmine_obj = sgp.ParticleGRAANK(data_src)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```\r\n* **n_particles** - *[optional]* initial particle population ```default = 5```\r\n* **velocity** - *[optional]* particle velocity ```default = 0.9```\r\n* **coeff_p** - *[optional]* personal coefficient rate ```default = 0.01```\r\n* **coeff_g** - *[optional]* global coefficient ```default = 0.9```\r\n\r\n### 5. Local Search for GPs (LS-GRAANK)\r\nIn this approach, it is assumed that every GP candidate may be represented as a position that has a cost value associated with it. The cost is derived from the computed support of that candidate, the higher the support value the lower the cost. The aim of the algorithm is search through group of positions and find those with the lowest cost as efficiently as possible.\r\n\r\n```python\r\n\r\nmine_obj = sgp.HillClimbingGRAANK(data_src, min_sup)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```\r\n* **step_size** - *[optional]* step size ```default = 0.5```\r\n\r\n\r\n### 6. Random Search for GPs (RS-GRAANK)\r\nIn this approach, it is assumed that every GP candidate may be represented as a position that has a cost value associated with it. The cost is derived from the computed support of that candidate, the higher the support value the lower the cost. The aim of the algorithm is search through group of positions and find those with the lowest cost as efficiently as possible.\r\n\r\n```python\r\nimport so4gp as sgp\r\n\r\nmine_obj = sgp.RandomGRAANK(data_src, min_sup)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **max_iteration** - *[optional]* maximum number of algorithm iterations ```default = 1```\r\n\r\n\r\n### 7. Clustering algorithm for GPs (Clu-BFS)\r\nWe borrow the net-win concept used in the work 'Clustering Using Pairwise Comparisons' proposed by R. Srikant to the problem of extracting gradual patterns (GPs). In order to mine for GPs, each feature yields 2 gradual items which we use to construct a bitmap matrix comparing each row to each other (i.e., (r1,r2), (r1,r3), (r1,r4), (r2,r3), (r2,r4), (r3,r4)).\r\n\r\nIn this approach, we convert the bitmap matrices into 'net-win vectors'. Finally, we apply spectral clustering to determine which gradual items belong to the same group based on the similarity of net-win vectors. Gradual items in the same cluster should have almost similar score vector.\r\n\r\n```python\r\nimport so4gp as sgp\r\n\r\nmine_obj = sgp.ClusterGP(data_source=data_src, min_sup=0.5, e_prob=0.1)\r\ngp_json = mine_obj.discover()\r\nprint(gp_json)\r\n```\r\n\r\nwhere you specify the parameters as follows:\r\n\r\n* **data_src** - *[required]* data source {either a ```file in csv format``` or a ```Pandas DataFrame```}\r\n* **min_sup** - *[optional]* minimum support ```default = 0.5```\r\n* **e_probability** - *[optional]* erasure probability ```default = 0.5```\r\n* **max_iteration** - *[optional]* maximum iterations for estimating score vectors ```default = 10```\r\n\r\n\r\n## Sample Output\r\nThe default output is the format of JSON:\r\n\r\n```json\r\n{\r\n\t\"Algorithm\": \"RS-GRAANK\",\r\n\t\"Best Patterns\": [\r\n [[\"Age+\", \"Salary+\"], 0.6], \r\n [[\"Expenses-\", \"Age+\", \"Salary+\"], 0.6]\r\n\t],\r\n\t\"Iterations\": 20\r\n}\r\n```\r\n\r\n### References\r\n* Owuor, D., Runkler T., Laurent A., Menya E., Orero J (2021), Ant Colony Optimization for Mining Gradual Patterns. International Journal of Machine Learning and Cybernetics. https://doi.org/10.1007/s13042-021-01390-w\r\n* Dickson Owuor, Anne Laurent, and Joseph Orero (2019). Mining Fuzzy-temporal Gradual Patterns. In the proceedings of the 2019 IEEE International Conference on Fuzzy Systems (FuzzIEEE). IEEE. https://doi.org/10.1109/FUZZ-IEEE.2019.8858883.\r\n* Laurent A., Lesot MJ., Rifqi M. (2009) GRAANK: Exploiting Rank Correlations for Extracting Gradual Itemsets. In: Andreasen T., Yager R.R., Bulskov H., Christiansen H., Larsen H.L. (eds) Flexible Query Answering Systems. FQAS 2009. Lecture Notes in Computer Science, vol 5822. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-04957-6_33\r\n",
"bugtrack_url": null,
"license": "MIT License Copyright (c) 2021 Dickson Owuor (Ph.D.) 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. ",
"summary": "Some Python optimization algorithms for mining gradual patterns.",
"version": "0.6.5",
"project_urls": {
"Bug Tracker": "https://github.com/owuordickson/sogp_pypi/issues",
"Changelog": "https://github.com/owuordickson/sogp_pypi/blob/main/CHANGELOG.md",
"Documentation": "http://sogp-pypi.readthedocs.io",
"Homepage": "https://github.com/owuordickson/sogp_pypi",
"Repository": "https://github.com/owuordickson/sogp_pypi.git"
},
"split_keywords": [
"gradual patterns",
" graank",
" ant-colony-optimization",
" data-mining",
" swarm-intelligence"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "6d328d0a006c1b0d45be1361cb8cb74d2065d2b9fd1ec1f0f08691b936c60fe1",
"md5": "c5f8f05ec7d08a0e008ab0e014678d7d",
"sha256": "8456991b1ef919a7a17f03cb5b639160d9049f892dd6cc8c8d0da6c05eab9567"
},
"downloads": -1,
"filename": "so4gp-0.6.5-py3-none-any.whl",
"has_sig": false,
"md5_digest": "c5f8f05ec7d08a0e008ab0e014678d7d",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.9",
"size": 40384,
"upload_time": "2024-11-13T10:04:57",
"upload_time_iso_8601": "2024-11-13T10:04:57.567280Z",
"url": "https://files.pythonhosted.org/packages/6d/32/8d0a006c1b0d45be1361cb8cb74d2065d2b9fd1ec1f0f08691b936c60fe1/so4gp-0.6.5-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "d761ebf68166a0de4f8d4c2549cb6048dfcbca9df9f9d271c83717fc639a58dd",
"md5": "dda5b18e378469120fc69a2766d10ba2",
"sha256": "8fd0ccd6d13176756f8060c7d9558d94a0c25c56284c6d40c7733c75feccb101"
},
"downloads": -1,
"filename": "so4gp-0.6.5.tar.gz",
"has_sig": false,
"md5_digest": "dda5b18e378469120fc69a2766d10ba2",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.9",
"size": 41070,
"upload_time": "2024-11-13T10:04:59",
"upload_time_iso_8601": "2024-11-13T10:04:59.885123Z",
"url": "https://files.pythonhosted.org/packages/d7/61/ebf68166a0de4f8d4c2549cb6048dfcbca9df9f9d271c83717fc639a58dd/so4gp-0.6.5.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-13 10:04:59",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "owuordickson",
"github_project": "sogp_pypi",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [],
"lcname": "so4gp"
}
