[](https://github.com/fidelity/seq2pat/actions/workflows/ci.yml) [](https://pypi.python.org/pypi/seq2pat/) [](https://pypi.python.org/pypi/seq2pat/) [](http://makeapullrequest.com) [](https://pepy.tech/project/seq2pat)
Seq2Pat: Sequence-to-Pattern Generation Library
===============================================
Seq2Pat ([AI Magazine'23](https://onlinelibrary.wiley.com/doi/epdf/10.1002/aaai.12081), [AAAI'22](https://ojs.aaai.org/index.php/AAAI/article/view/21542)) is a research library for sequence-to-pattern generation to discover
sequential patterns that occur frequently in large sequence databases.
The library supports constraint-based reasoning to specify
desired properties over patterns.
Dichomotic Pattern Mining ([KDF@AAAI'22](https://arxiv.org/abs/2201.09178), [Frontiers'22](https://www.frontiersin.org/articles/10.3389/frai.2022.868085/full)) embeds Seq2Pat to exploit the dichotomy of positive vs. negative outcomes in populations. This allows constraint-based sequence analysis to generate patterns that uniquely distinguishes cohorts. These patterns can be turned into feature vectors to feed into machine learning models for downstream tasks, e.g., intent prediction, intruder detection, and more generally, for digital behavior analysis.
From an algorithmic perspective, the library takes advantage of
[multi-valued decision diagrams (AAAI'19)](https://aaai.org/ojs/index.php/AAAI/article/view/3962).
From an implementation perspective, the library is written in ```Cython```
that brings together the efficiency of a low-level ```C++``` backend and
the expressiveness of a high-level ```Python``` public interface.
Seq2Pat is developed as a joint collaboration between Fidelity Investments
and the Tepper School of Business at CMU. Documentation is available at [fidelity.github.io/seq2pat](https://fidelity.github.io/seq2pat).
## Quick Start
We present examples for constraint-based sequential pattern mining and dichotomic pattern mining.
Sequences can be represented as strings or positive integers.
### Constraint-based Sequential Pattern Mining
```python
# Example to show how to find frequent sequential patterns
# from a given sequence database subject to constraints
from sequential.seq2pat import Seq2Pat, Attribute
# Seq2Pat over 3 sequences
seq2pat = Seq2Pat(sequences=[["A", "A", "B", "A", "D"],
["C", "B", "A"],
["C", "A", "C", "D"]])
# Price attribute corresponding to each item
price = Attribute(values=[[5, 5, 3, 8, 2],
[1, 3, 3],
[4, 5, 2, 1]])
# Average price constraint
seq2pat.add_constraint(3 <= price.average() <= 4)
# Patterns that occur at least twice (A-D)
patterns = seq2pat.get_patterns(min_frequency=2)
```
### Mining Large Sequence Databases
Seq2Pat provides two parameters to mine large-sequence databases efficiently. The Seq2Pat constructor enables `max_span`, the maximum span parameter that controls the columns, i.e., attributes, and `batch_size`, the batch size parameter that controls the rows, i.e., the sequences.
* **Maximum Span:** The span of the pattern can be controlled using the [max_span](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L297) parameter. By default, the span is restricted to ten to avoid performance issues in out-of-the-box performance for general users. Setting `max_span = None` removes this restriction.
* **Batch Size:** The number of sequences in each batch used for pattern mining is controlled by [batch_size](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L303). By default, the batch size is not restricted, meaning the entire data will be used, up to `dynamic_batch_threshold`. If the input dataset size is greater than the [dynamic batch size threshold](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L131), then batching is activated automatically using the [default batch size](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L135). The final set of patterns is the aggregation of patterns over all batches. The `min_frequency` is still enforced whereby a [discount_factor](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L315) is applied to each batch. It is possible that results of mining in batches differ from mining the entire set. The chance of this occurrence is minimized when using a small discount factor. By default, the discount factor is set to 0.2. For further speed-up, batch mining can be parallelized using [n_jobs](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L324) parameter. By default, the number of jobs is set to two.
```python
# Seq2Pat parameters to consider when dealing with large sequence databases
seq2pat = Seq2Pat(sequences=[[], ..large sequence database.., []],
max_span=10,
batch_size=10000,
discount_factor=0.2,
n_jobs=2)
```
### Dichotomic Pattern Mining
```python
# Example to show how to run Dichotomic Pattern Mining
# on sequences with positive and negative outcomes
from sequential.seq2pat import Seq2Pat
from sequential.pat2feat import Pat2Feat
from sequential.dpm import dichotomic_pattern_mining, DichotomicAggregation
# Create seq2pat model for positive sequences
sequences_pos = [["A", "A", "B", "A", "D"]]
seq2pat_pos = Seq2Pat(sequences=sequences_pos)
# Create seq2pat model for negative sequences
sequences_neg = [["C", "B", "A"], ["C", "A", "C", "D"]]
seq2pat_neg = Seq2Pat(sequences=sequences_neg)
# Run DPM to mine patterns that are aggregated as the
# union, intersection, or the unique patterns among positive and negative sequences
aggregation_to_patterns = dichotomic_pattern_mining(seq2pat_pos, seq2pat_neg,
min_frequency_pos=1,
min_frequency_neg=2)
# DPM patterns with union aggregation of positive and negative patterns
# see also intersection, unique_pos, and unique_neq
dpm_patterns = aggregation_to_patterns[DichotomicAggregation.union]
# Most interestingly, we can generate features from DPM patterns via pat2feat
# These features can be used in ML for downstream tasks, e.g., intent prediction
# To do that, we turn the input sequences into one-hot feature vectors
# Binary features denote existence of found patterns in each sequence
pat2feat = Pat2Feat()
sequences = sequences_pos + sequences_neg
encodings = pat2feat.get_features(sequences, dpm_patterns, drop_pattern_frequency=False)
# These encodings can be used as feature vectors in ML models
# to predict the positive vs. negative labels in the dataset
```
## Available Constraints
The library offers various constraint types, including a number of non-monotone constraints.
* **Average**: This constraint specifies the average value of an attribute across all events in a pattern.
* **Gap**: This constraint specifies the difference between the attribute values of every two consecutive events in a pattern.
* **Median**: This constraint specifies the median value of an attribute across all events in a pattern.
* **Span**: This constraint specifies the difference between the maximum and the minimum value of an attribute across all events in a pattern.
## Usage Examples
Examples on how to use the available constraints can be found
in the [Usage Example Notebook](https://github.com/fidelity/seq2pat/blob/master/notebooks/sequential_pattern_mining.ipynb).
You can also find out how to scale up the mining capability, by running Seq2Pat on batches of sequences in parallel in [Batch Processing Notebook](https://github.com/fidelity/seq2pat/blob/master/notebooks/batch_processing.ipynb).
Supported by Seq2Pat, we proposed **Dichotomic Pattern Mining (DPM)** ([X. Wang and S. Kadioglu, 2022](https://arxiv.org/abs/2201.09178)) to analyze the correlations between
mined patterns and different outcomes of sequences. DPM allows generating feature vectors based on mined patterns and plays an integrator role between Sequential
Pattern Mining and the downstream modeling tasks as shown in [Ghosh et. al., Frontiers'22](https://www.frontiersin.org/articles/10.3389/frai.2022.868085/full) for clickstream intent prediction and intruder detection. An example on how to run DPM and generate pattern embeddings can be found in
[Dichotomic Pattern Mining Notebook](https://github.com/fidelity/seq2pat/blob/master/notebooks/dichotomic_pattern_mining.ipynb).
## Installation
Seq2Pat can be installed from PyPI using ```pip install seq2pat```. It can also be installed from source by following the instructions in
our [documentation](https://fidelity.github.io/seq2pat/installation.html).
### Requirements
The library requires **Python 3.8+**, the ```Cython``` package, and a ```C++``` compiler.
See [requirements.txt](requirements.txt) for dependencies.
## Support
Please submit bug reports, questions and feature requests as [Issues](https://github.com/fidelity/seq2pat/issues).
## Citation
If you use Seq2Pat in a publication, please cite it as:
```bibtex
@article{https://doi.org/10.1002/aaai.12081,
author = {Kadioglu, Serdar and Wang, Xin and Hosseininasab, Amin and van Hoeve, Willem-Jan},
title = {Seq2Pat: Sequence-to-pattern generation to bridge pattern mining with machine learning},
journal = {AI Magazine},
volume = {44},
number = {1},
pages = {54-66},
doi = {https://doi.org/10.1002/aaai.12081},
url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/aaai.12081},
eprint = {https://onlinelibrary.wiley.com/doi/epdf/10.1002/aaai.12081},
year = {2023}
}
```
```bibtex
@article{seq2pat2022,
title={Seq2Pat: Sequence-to-Pattern Generation for Constraint-based Sequential Pattern Mining},
author={Wang Xin, Hosseininasab Amin, Colunga Pablo, Kadioglu Serdar, van Hoeve Willem-Jan},
journal={Proceedings of the AAAI Conference on Artificial Intelligence},
url={https://ojs.aaai.org/index.php/AAAI/article/view/21542},
volume={36},
number={11},
pages={12665-12671},
year={2022}
}
```
To cite the Dichotomic Pattern Mining framework, please cite it as:
```bibtex
@article{Frontiers2022,
title={Dichotomic Pattern Mining Integrated with Constraint Reasoning for Digital Behaviour Analyses},
author={Sohom Ghosh, Shefali Yadav, Xin Wang, Bibhash Chakrabarty, Serdar Kadioglu},
journal={Frontiers in Artificial Intelligence},
url={https://www.frontiersin.org/articles/10.3389/frai.2022.868085},
volume={5},
year={2022}
}
```
```bibtex
@inproceedings{DPM2022,
title={Dichotomic Pattern Mining with Applications to Intent Prediction from Semi-Structured Clickstream Datasets},
author={Xin Wang and Serdar Kadioglu},
booktitle={The AAAI-22 Workshop on Knowledge Discovery from Unstructured Data in Financial Services},
publisher={arXiv},
url={https://arxiv.org/abs/2201.09178},
year={2022}
}
```
## License
Seq2Pat is licensed under the [GNU GPL License 2.0](LICENSE).
<br>
Raw data
{
"_id": null,
"home_page": "https://github.com/fidelity/seq2pat",
"name": "seq2pat",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": null,
"author": "FMR LLC",
"author_email": null,
"download_url": "https://files.pythonhosted.org/packages/b2/aa/82c8f7ec142613fd2cd9bed720f386742e7293cb3c4b70e7b459b07a98d5/seq2pat-2.0.0.tar.gz",
"platform": null,
"description": "[](https://github.com/fidelity/seq2pat/actions/workflows/ci.yml) [](https://pypi.python.org/pypi/seq2pat/) [](https://pypi.python.org/pypi/seq2pat/) [](http://makeapullrequest.com) [](https://pepy.tech/project/seq2pat)\n\n\nSeq2Pat: Sequence-to-Pattern Generation Library\n===============================================\n\nSeq2Pat ([AI Magazine'23](https://onlinelibrary.wiley.com/doi/epdf/10.1002/aaai.12081), [AAAI'22](https://ojs.aaai.org/index.php/AAAI/article/view/21542)) is a research library for sequence-to-pattern generation to discover\nsequential patterns that occur frequently in large sequence databases.\nThe library supports constraint-based reasoning to specify\ndesired properties over patterns.\n\nDichomotic Pattern Mining ([KDF@AAAI'22](https://arxiv.org/abs/2201.09178), [Frontiers'22](https://www.frontiersin.org/articles/10.3389/frai.2022.868085/full)) embeds Seq2Pat to exploit the dichotomy of positive vs. negative outcomes in populations. This allows constraint-based sequence analysis to generate patterns that uniquely distinguishes cohorts. These patterns can be turned into feature vectors to feed into machine learning models for downstream tasks, e.g., intent prediction, intruder detection, and more generally, for digital behavior analysis. \n\nFrom an algorithmic perspective, the library takes advantage of\n[multi-valued decision diagrams (AAAI'19)](https://aaai.org/ojs/index.php/AAAI/article/view/3962).\n\nFrom an implementation perspective, the library is written in ```Cython```\nthat brings together the efficiency of a low-level ```C++``` backend and\nthe expressiveness of a high-level ```Python``` public interface.\n\nSeq2Pat is developed as a joint collaboration between Fidelity Investments\nand the Tepper School of Business at CMU. Documentation is available at [fidelity.github.io/seq2pat](https://fidelity.github.io/seq2pat).\n\n## Quick Start\n\nWe present examples for constraint-based sequential pattern mining and dichotomic pattern mining. \nSequences can be represented as strings or positive integers.\n\n### Constraint-based Sequential Pattern Mining\n```python\n# Example to show how to find frequent sequential patterns\n# from a given sequence database subject to constraints\nfrom sequential.seq2pat import Seq2Pat, Attribute\n\n# Seq2Pat over 3 sequences\nseq2pat = Seq2Pat(sequences=[[\"A\", \"A\", \"B\", \"A\", \"D\"],\n [\"C\", \"B\", \"A\"],\n [\"C\", \"A\", \"C\", \"D\"]])\n\n# Price attribute corresponding to each item\nprice = Attribute(values=[[5, 5, 3, 8, 2],\n [1, 3, 3],\n [4, 5, 2, 1]])\n\n# Average price constraint\nseq2pat.add_constraint(3 <= price.average() <= 4)\n\n# Patterns that occur at least twice (A-D)\npatterns = seq2pat.get_patterns(min_frequency=2)\n```\n\n### Mining Large Sequence Databases \nSeq2Pat provides two parameters to mine large-sequence databases efficiently. The Seq2Pat constructor enables `max_span`, the maximum span parameter that controls the columns, i.e., attributes, and `batch_size`, the batch size parameter that controls the rows, i.e., the sequences. \n\n* **Maximum Span:** The span of the pattern can be controlled using the [max_span](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L297) parameter. By default, the span is restricted to ten to avoid performance issues in out-of-the-box performance for general users. Setting `max_span = None` removes this restriction.\n\n* **Batch Size:** The number of sequences in each batch used for pattern mining is controlled by [batch_size](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L303). By default, the batch size is not restricted, meaning the entire data will be used, up to `dynamic_batch_threshold`. If the input dataset size is greater than the [dynamic batch size threshold](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L131), then batching is activated automatically using the [default batch size](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L135). The final set of patterns is the aggregation of patterns over all batches. The `min_frequency` is still enforced whereby a [discount_factor](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L315) is applied to each batch. It is possible that results of mining in batches differ from mining the entire set. The chance of this occurrence is minimized when using a small discount factor. By default, the discount factor is set to 0.2. For further speed-up, batch mining can be parallelized using [n_jobs](https://github.com/fidelity/seq2pat/blob/master/sequential/seq2pat.py#L324) parameter. By default, the number of jobs is set to two. \n\n```python\n# Seq2Pat parameters to consider when dealing with large sequence databases\nseq2pat = Seq2Pat(sequences=[[], ..large sequence database.., []],\n max_span=10,\n batch_size=10000,\n discount_factor=0.2,\n n_jobs=2)\n```\n\n\n### Dichotomic Pattern Mining\n```python\n# Example to show how to run Dichotomic Pattern Mining \n# on sequences with positive and negative outcomes\nfrom sequential.seq2pat import Seq2Pat\nfrom sequential.pat2feat import Pat2Feat\nfrom sequential.dpm import dichotomic_pattern_mining, DichotomicAggregation\n\n# Create seq2pat model for positive sequences\nsequences_pos = [[\"A\", \"A\", \"B\", \"A\", \"D\"]]\nseq2pat_pos = Seq2Pat(sequences=sequences_pos)\n\n# Create seq2pat model for negative sequences\nsequences_neg = [[\"C\", \"B\", \"A\"], [\"C\", \"A\", \"C\", \"D\"]]\nseq2pat_neg = Seq2Pat(sequences=sequences_neg)\n\n# Run DPM to mine patterns that are aggregated as the \n# union, intersection, or the unique patterns among positive and negative sequences\naggregation_to_patterns = dichotomic_pattern_mining(seq2pat_pos, seq2pat_neg, \n min_frequency_pos=1, \n min_frequency_neg=2)\n\n# DPM patterns with union aggregation of positive and negative patterns\n# see also intersection, unique_pos, and unique_neq\ndpm_patterns = aggregation_to_patterns[DichotomicAggregation.union]\n\n# Most interestingly, we can generate features from DPM patterns via pat2feat\n# These features can be used in ML for downstream tasks, e.g., intent prediction\n# To do that, we turn the input sequences into one-hot feature vectors\n# Binary features denote existence of found patterns in each sequence\npat2feat = Pat2Feat()\nsequences = sequences_pos + sequences_neg\nencodings = pat2feat.get_features(sequences, dpm_patterns, drop_pattern_frequency=False)\n\n# These encodings can be used as feature vectors in ML models\n# to predict the positive vs. negative labels in the dataset\n```\n\n## Available Constraints\n\nThe library offers various constraint types, including a number of non-monotone constraints.\n\n* **Average**: This constraint specifies the average value of an attribute across all events in a pattern.\n* **Gap**: This constraint specifies the difference between the attribute values of every two consecutive events in a pattern.\n* **Median**: This constraint specifies the median value of an attribute across all events in a pattern.\n* **Span**: This constraint specifies the difference between the maximum and the minimum value of an attribute across all events in a pattern.\n\n## Usage Examples\n\nExamples on how to use the available constraints can be found \nin the [Usage Example Notebook](https://github.com/fidelity/seq2pat/blob/master/notebooks/sequential_pattern_mining.ipynb).\nYou can also find out how to scale up the mining capability, by running Seq2Pat on batches of sequences in parallel in [Batch Processing Notebook](https://github.com/fidelity/seq2pat/blob/master/notebooks/batch_processing.ipynb). \n\nSupported by Seq2Pat, we proposed **Dichotomic Pattern Mining (DPM)** ([X. Wang and S. Kadioglu, 2022](https://arxiv.org/abs/2201.09178)) to analyze the correlations between \nmined patterns and different outcomes of sequences. DPM allows generating feature vectors based on mined patterns and plays an integrator role between Sequential \nPattern Mining and the downstream modeling tasks as shown in [Ghosh et. al., Frontiers'22](https://www.frontiersin.org/articles/10.3389/frai.2022.868085/full) for clickstream intent prediction and intruder detection. An example on how to run DPM and generate pattern embeddings can be found in \n[Dichotomic Pattern Mining Notebook](https://github.com/fidelity/seq2pat/blob/master/notebooks/dichotomic_pattern_mining.ipynb).\n\n## Installation\n\nSeq2Pat can be installed from PyPI using ```pip install seq2pat```. It can also be installed from source by following the instructions in\nour [documentation](https://fidelity.github.io/seq2pat/installation.html).\n\n### Requirements\n\nThe library requires **Python 3.8+**, the ```Cython``` package, and a ```C++``` compiler.\nSee [requirements.txt](requirements.txt) for dependencies.\n\n## Support\n\nPlease submit bug reports, questions and feature requests as [Issues](https://github.com/fidelity/seq2pat/issues).\n\n## Citation\n\nIf you use Seq2Pat in a publication, please cite it as:\n\n```bibtex\n @article{https://doi.org/10.1002/aaai.12081,\n author = {Kadioglu, Serdar and Wang, Xin and Hosseininasab, Amin and van Hoeve, Willem-Jan},\n title = {Seq2Pat: Sequence-to-pattern generation to bridge pattern mining with machine learning},\n journal = {AI Magazine},\n volume = {44},\n number = {1},\n pages = {54-66},\n doi = {https://doi.org/10.1002/aaai.12081},\n url = {https://onlinelibrary.wiley.com/doi/abs/10.1002/aaai.12081},\n eprint = {https://onlinelibrary.wiley.com/doi/epdf/10.1002/aaai.12081},\n year = {2023}\n }\n```\n\n```bibtex\n @article{seq2pat2022,\n title={Seq2Pat: Sequence-to-Pattern Generation for Constraint-based Sequential Pattern Mining},\n author={Wang Xin, Hosseininasab Amin, Colunga Pablo, Kadioglu Serdar, van Hoeve Willem-Jan},\n journal={Proceedings of the AAAI Conference on Artificial Intelligence},\n url={https://ojs.aaai.org/index.php/AAAI/article/view/21542},\n volume={36},\n number={11},\n pages={12665-12671},\n year={2022}\n }\n```\n\nTo cite the Dichotomic Pattern Mining framework, please cite it as:\n\n```bibtex\n @article{Frontiers2022,\n title={Dichotomic Pattern Mining Integrated with Constraint Reasoning for Digital Behaviour Analyses}, \n author={Sohom Ghosh, Shefali Yadav, Xin Wang, Bibhash Chakrabarty, Serdar Kadioglu},\n journal={Frontiers in Artificial Intelligence},\n url={https://www.frontiersin.org/articles/10.3389/frai.2022.868085},\n volume={5},\n year={2022} \n}\n```\n\n```bibtex\n@inproceedings{DPM2022,\n title={Dichotomic Pattern Mining with Applications to Intent Prediction from Semi-Structured Clickstream Datasets}, \n author={Xin Wang and Serdar Kadioglu},\n booktitle={The AAAI-22 Workshop on Knowledge Discovery from Unstructured Data in Financial Services},\n publisher={arXiv},\n url={https://arxiv.org/abs/2201.09178},\n year={2022}\n}\n```\n\n## License\n\nSeq2Pat is licensed under the [GNU GPL License 2.0](LICENSE).\n\n<br>\n",
"bugtrack_url": null,
"license": null,
"summary": "Seq2Pat: Sequence-to-Pattern Generation Library",
"version": "2.0.0",
"project_urls": {
"Documentation": "https://fidelity.github.io/seq2pat/",
"Homepage": "https://github.com/fidelity/seq2pat",
"Source": "https://github.com/fidelity/seq2pat"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "d599a44f56497c968306b78b8d71350cacf875a2c7d60f3ea38268b1e60b9122",
"md5": "d4918856541344d837211c72ebb378f3",
"sha256": "60133540b9a3245998f00730cabf1074642746a99e30304272f60c720b36691a"
},
"downloads": -1,
"filename": "seq2pat-2.0.0-cp38-cp38-macosx_10_9_x86_64.whl",
"has_sig": false,
"md5_digest": "d4918856541344d837211c72ebb378f3",
"packagetype": "bdist_wheel",
"python_version": "cp38",
"requires_python": null,
"size": 185097,
"upload_time": "2024-06-03T19:31:00",
"upload_time_iso_8601": "2024-06-03T19:31:00.199599Z",
"url": "https://files.pythonhosted.org/packages/d5/99/a44f56497c968306b78b8d71350cacf875a2c7d60f3ea38268b1e60b9122/seq2pat-2.0.0-cp38-cp38-macosx_10_9_x86_64.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "b2aa82c8f7ec142613fd2cd9bed720f386742e7293cb3c4b70e7b459b07a98d5",
"md5": "7cac0af44ed81234a6e5f9359ad32685",
"sha256": "895822fc011c9e7bf70209ff831c803773eb420f0a3a83b36736966b97689b8d"
},
"downloads": -1,
"filename": "seq2pat-2.0.0.tar.gz",
"has_sig": false,
"md5_digest": "7cac0af44ed81234a6e5f9359ad32685",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 181291,
"upload_time": "2024-06-03T19:31:05",
"upload_time_iso_8601": "2024-06-03T19:31:05.700560Z",
"url": "https://files.pythonhosted.org/packages/b2/aa/82c8f7ec142613fd2cd9bed720f386742e7293cb3c4b70e7b459b07a98d5/seq2pat-2.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-06-03 19:31:05",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "fidelity",
"github_project": "seq2pat",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"requirements": [
{
"name": "cython",
"specs": [
[
">=",
"0.29.13"
]
]
},
{
"name": "ortools",
"specs": []
},
{
"name": "numpy",
"specs": []
},
{
"name": "pandas",
"specs": []
},
{
"name": "joblib",
"specs": []
}
],
"lcname": "seq2pat"
}
JSON
