semvec/pypi-packages huggingface dataset:
rdsclient 0.1.0
A Python wrapper for querying AWS RDS with mysql-connector-python, returning Pandas or Spark DataFrames.
License: MIT
Requires Python: >=3.7

# rdsclient

 is a Python package designed to simplify the interaction with AWS RDS instances using the  package. It allows executing SQL queries and fetching the results as Pandas or Spark DataFrames.

## Features

- **Singleton RDS connection**: Ensures a single connection to the RDS instance.
- **Query execution**: Execute SELECT, INSERT, UPDATE, DELETE queries on your RDS database.
- **Return data as Pandas DataFrame**: Fetch query results directly as Pandas DataFrames for easy data manipulation.
- **Spark DataFrame support**: Optionally convert query results to Spark DataFrames for distributed computing.
- **Context-managed MySQL connection**: Automatically manage the connection lifecycle with Python's .

## Installation

You can install  directly from PyPI:

```bash
pip install rdsclient
```

### Prerequisites

- **Python 3.7+**
- **Dependencies**:
  - 
  - 
  - 

These dependencies are automatically installed when you install .

## Usage

### Simple Query Example

```python
from rdsclient import query_rds

# Define your RDS connection details
host = 'your-rds-host'
user = 'your-username'
password = 'your-password'
database = 'your-database'

# Execute the query and get the result as a Pandas DataFrame
df = query_rds(
    query='SELECT * FROM your_table',
    host=host,
    user=user,
    password=password,
    database=database
)

# Display the result
print(df.head())
```

### Using the RDS Class Directly

```python
from rdsclient import RDS

# Create an RDS instance
rds = RDS(
    host='your-rds-host',
    user='your-username',
    password='your-password',
    database='your-database'
)

# Execute a query and fetch results as a Pandas DataFrame
df = rds.execute_query('SELECT * FROM your_table')

# Optionally, get the results as a Spark DataFrame
spark_df = rds.query_to_spark_df('SELECT * FROM your_table')

# Display the Pandas DataFrame
print(df.head())
```

### Executing Non-Select Queries

You can also execute non-SELECT queries (such as INSERT, UPDATE, DELETE):

```python
# Example for executing an UPDATE query
affected_rows = rds.execute_update('UPDATE your_table SET column_name = %s WHERE condition = %s', ('new_value', 'condition_value'))

print(f'{affected_rows} rows affected.')
```

## Contributing

Contributions are welcome! If you find a bug or have a feature request, please feel free to open an issue or submit a pull request.

### Steps for Contributing:
1. Fork the repository.
2. Create a feature branch (`git checkout -b feature-name`).
3. Commit your changes (`git commit -am 'Add feature'`).
4. Push to the branch (`git push origin feature-name`).
5. Create a new pull request.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
python-data-structures-bootcamp 0.1.3
This is my first try in building package
License: MIT
Requires Python: >=3.6

# Python Data Structures

A Python package that provides implementations of common data structures such as:

- Singly Linked List
- Stack
- Queue
- Binary Tree
- Array

This package is designed to be an easy-to-use resource for anyone interested in learning or working with fundamental data structures in Python.

---

## Features

- **Singly Linked List**: A linked list where each node points to the next node.
- **Stack**: A LIFO (Last In First Out) data structure where elements are added and removed from the top.
- **Queue**: A FIFO (First In First Out) data structure where elements are added at the rear and removed from the front.
- **Binary Tree**: A tree structure where each node has at most two children, with left and right pointers.

---

## Installation

You can install the package using `pip`:

```bash
pip install python-basic-data-structures
```

---

## Usage

### Singly Linked List

To use the Singly Linked List:

```python
from my_data_structures.linked_list import LinkedList

# Create a LinkedList
ll = LinkedList()

# Insert elements
ll.insertAtBeginning(10)
ll.insertAtEnd(20)
ll.insertAfter(15, 1)

# Display the linked list
ll.display()

# Sort the list
ll.bubble_sort()
ll.display()
```

### Stack

To use the Stack:

```python
from my_data_structures.stack import Stack

# Create a Stack
stack = Stack()

# Push elements
stack.push(10)
stack.push(20)

# Pop elements
stack.pop()

# Display the stack
stack.display()
```

### Queue

To use the Queue:

```python
from my_data_structures.queue import MyQueue

# Create a Queue with a size limit
queue = MyQueue(3)

# Enqueue elements
queue.enqueue(10)
queue.enqueue(20)

# Dequeue elements
queue.dequeue()

# Display the queue
queue.display()
```

### Binary Tree

To use the Binary Tree:

```python
from my_data_structures.binary_tree import BinaryTree

# Create a Binary Tree
bt = BinaryTree()

# Insert elements
bt.insert(10)
bt.insert(20)
bt.insert(5)

# Search for a value
bt.search(15)

# Display the tree in different orders
print(bt.inorder())
print(bt.preorder())
print(bt.postorder())
```

---

## Contributing

Contributions are welcome! If you'd like to improve the project, feel free to fork the repository, make your changes, and submit a pull request. Here are a few ways you can contribute:

- Implementing new data structures.
- Adding tests for existing structures.
- Improving documentation.

---

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

---

## Contact

If you have any questions or suggestions, feel free to open an issue on GitHub or contact me directly:

- **Email**: amahamat@aimsammi.org
- **GitHub**: [@Mahamat19](https://github.com/Mahamat19)

---

You can customize the content according to your needs, but this should serve as a solid base for your project's README. It includes essential sections like an introduction, installation instructions, usage examples, contributing guidelines, and contact information.
clumpi 1.0.1
Calculate Clumpiness index by Zhang, Bradlow and Small (2015)
License: MIT
Keywords: RFMC Clumpiness marketing CRM

# clumpi [klˈʌmpάɪ]

[![PyPI](https://img.shields.io/pypi/v/clumpi.svg)](https://pypi.org/project/clumpi/)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15202295.svg)](https://doi.org/10.5281/zenodo.15202295)

![sample data in pandas DataFrame](images/sample1.png)
## Overview
A simple python package to calculate Clumpiness for RMFC analysis by Zhang, Bradlow & Small (2015).
Easy use with `clumpi.get_RFC()`

## Requirements
- Python
- pandas
- numpy
- matplotlib

works well with Google Colab.

## Installation
Simply use ```pip install``` for install this from PyPI:
```bash
pip install clumpi
```
or you can from Git repo:
```bash
pip install git+https://github.com/jniimi/clumpi.git
```
(perhaps, git repo version may be newer.)

## Dataset
Use your discrete time-series event data with ID and time. 
- Create DataFrame that records only the point in time when the event occurred in the time series data. 
- The name of the variables can be anything.

| user_id | t       |
|:--------|--------:|
| Ava     | 1       |
| Ava     | 4       |
| ...     | ...     |
| Jack    | 3       |
| Jack    | 10      |
| ...     | ...     |

Check out our sample dataset for further details.
```python
df = clumpi.load_sample_data()
display(df)
```
![sample data in pandas DataFrame](images/sample2.png)

## Usage
### Log to Clumpiness
Use the function `clumpi.get_RFC()` to calculate. Specify following arguments.
- `id`: a column name indicating user
- `t`: a column name indicating discrete time (e.g., a day in a month), **t starts from 1 (Not 0)**.
- `N`: a maximum number of events during the period (e.g., # of days in a month)
- `M` (optional): a number of iterations for the simulation to calculate threshold (3000 for default)
- `alpha` (optional): a significance level for the test of regularity (0.05 for default)
- `plot` (optional): bool whether plot the frequency by users

  By specifying the argument `plot`=True, then the function displays the following scatter plot.
![scatter plot by user_id](images/sample3.png)

### Simply Calculate H0
Use the function `clumpi.calc_threshold()` to calculate upper `alpha` % point in `M` times simulation. 

All you need to specify are `N`, `M`, and `alpha` (See `clumpi.get_RFC`).

# Acknoledgement
The simulation in this package is based on Appendix B by Zhang et al. (2015).

Zhang, Y., Bradlow, E. T., & Small, D. S. (2015). Predicting customer value using clumpiness: From RFM to RFMC. Marketing Science, 34(2), 195-208.
https://doi.org/10.1287/mksc.2014.0873

# Author and Citation
jniimi ([@JvckAndersen](https://x.com/JvckAndersen))

```
@misc{niimi2024clumpi,
  author = {Junichiro Niimi},
  title = {clumpi: A Python package for calculating Clumpiness in RFMC analysis},
  year = {2024},
  publisher = {Zenodo},
  doi = {10.5281/zenodo.15202295},
  url = {https://github.com/jniimi/clumpi}
}
```
x2ttech 0.4.2
A Python library for amazing functionality
License: MIT
Requires Python: >=3.8
Keywords: erp, tiktok, odoo

# x2T Consulting

x2T Consulting specializes in delivering tailored solutions through the development and customization of Odoo addons. We are committed to creating high-quality products that meet the unique needs of businesses, enhancing management efficiency and streamlining workflows.

With a team of experienced professionals in the Odoo ecosystem, x2T Consulting takes pride in offering innovative and reliable solutions for all types of businesses.

Let x2T Consulting help elevate your business to the next level!

## Authors

- [x2T Technique](https://github.com/x2TTechnique)

### Contributors

- [@tim - Bùi Đức Tuấn](https://github.com/buiductuan-git)
- [@tammy - Nguyễn Thị Phương Tâm](https://github.com/Phuongtam)