semvec/pypi-packages huggingface dataset:
digital-marketing-portfolio 0.1.0
A modern portfolio website for digital marketing and SEO experts
Requires Python: >=3.8

# Digital Marketing & SEO Expert Portfolio

A modern, responsive portfolio website showcasing digital marketing and SEO expertise. Built with Flask and modern web technologies.

## Features

- Responsive design that works on all devices
- Dynamic blog section (coming soon with social media integration)
- Contact form
- Modern UI with smooth animations
- SEO optimized

## Installation

### Option 1: Install from PyPI (Recommended)

```bash
pip install digital-marketing-portfolio
```

### Option 2: Install from Source

1. Clone the repository:
```bash
git clone https://github.com/thadigitalguru/static-website.git
cd static-website
```

2. Create and activate a virtual environment (recommended):
```bash
# Windows
python -m venv venv
.\venv\Scripts\activate

# Linux/Mac
python3 -m venv venv
source venv/bin/activate
```

3. Install dependencies:
```bash
pip install -r requirements.txt
```

## Running the Site

### Option 1: Using the Installed Package

After installation, you can run the site using:

```bash
digital-portfolio
```

### Option 2: Running from Source

1. Start the Flask development server:
```bash
python src/app.py
```

2. Access the site:
- Local: http://localhost:5000
- Network: http://YOUR_IP_ADDRESS:5000

## Project Structure

```
static-website/
â”œâ”€â”€ src/
â”‚   â”œâ”€â”€ __init__.py         # Package initialization
â”‚   â”œâ”€â”€ app.py              # Flask application
â”‚   â”œâ”€â”€ templates/          # HTML templates
â”‚   â””â”€â”€ static/             # Static files (CSS, JS, images)
â”œâ”€â”€ setup.py                # Package setup file
â”œâ”€â”€ MANIFEST.in            # Package manifest
â”œâ”€â”€ requirements.txt        # Python dependencies
â””â”€â”€ README.md              # This file
```

## Development

- The site uses Flask for the backend
- Frontend is built with vanilla JavaScript and modern CSS
- Blog posts are currently static (social media integration coming soon)

## Contributing

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contact

Titus Kores - [@thadigitalguru](https://x.com/thadigitalguru) - [LinkedIn](https://www.linkedin.com/in/titus-kores-610201200/)
gittomarkdown 1.0.11
A tool to generate Markdown documentation from Git repositories
Requires Python: >=3.6

# GitToMarkdown

A Python tool that automatically generates Markdown documentation from Git repositories. It creates comprehensive documentation including directory structure and file contents in a well-organized Markdown format.

## Features

- Clone and document Git repositories via HTTPS or SSH
- Concurrent processing of multiple repositories
- Generate directory tree structure in Markdown
- Include file contents with syntax highlighting
- Support for XML and JSON input files containing repository URLs
- Progress bars for clone and documentation generation
- Configurable thread count for parallel processing

## Installation

```bash
pip install gittomarkdown
```

## Usage

### Basic Usage

```python
from GitToMarkdown.GTM import GitToMark

# Document a single repository
repo = GitToMark("https://github.com/username/repository.git")
repo.generate

# Document multiple repositories
repos = GitToMark([
    "https://github.com/user1/repo1.git",
    "https://github.com/user2/repo2.git"
])
repos.generate
```

### Using SSH

```python
# Configure SSH key path first
GitToMark.config(ssh_path="/path/to/your/ssh/key")

# Clone and document using SSH
repo = GitToMark("git@github.com:username/repository.git", ssh=True)
repo.generate
```

### Batch Processing from Files

```python
# From XML file
repos = GitToMark.from_xml("repositories.xml")
repos.generate

# From JSON file
repos = GitToMark.from_json("repositories.json")
repos.generate

# From text file (one URL per line)
repos = GitToMark.from_file("repositories.txt")
repos.generate
```

### Configuration

```python
# Configure thread count and SSH key path
GitToMark.config(threads=8, ssh_path="/path/to/ssh/key")
```

## Directory Structure

- `GitToMarkdown/`: Main package directory
  - `GTM.py`: Core functionality
  - `Generator.py`: Markdown generation logic
  - `MarkdownUtils.py`: Markdown formatting utilities
  - `Parsers.py`: Input file parsers
  - `ProgressBar.py`: Progress bar implementation
  - `Zipper.py`: Repository compression utility
  - `errors.py`: Custom error definitions

## Output

The generated documentation will be saved in the `Output` directory with the following format:
- Repository tree structure
- File contents with syntax highlighting based on file extension
- Organized sections with clear headers

## Requirements

- Python 3.6+
- GitPython
- requests
- tqdm
- configparser

## License

This project is under the MIT License.
pyQualitas 2.0.1
A project to ensure the data quality using python

**PyQualitas**

This project aims towards developing a python library ensure quality of the data. This project is an inspiration from deequ and 
dataflare which are also aimed towards the quality of the data.

**Requirements:**

1. Pyspark - Version 3.5.5 or greater
2. Pandas - Version 2.2.3 or greater
3. Jinja2 - Version 3.1.6 or greater
4. Slack-SDK - Version 3.35.0 or greater
5. PyMSTeams - Version 0.2.5 or greater

**Installation:**

The package can be installed as follows:

"pip install pyQualitas"

The test version of this package can be installed as follows:

"pip install -i https://test.pypi.org/simple/ pyQualitas"

**Use Cases:**

The main agenda behind creating this library is to help the QA Engineers to ensure quality of the data. Given the volume of the data & the frequency of the releases happening in the industry, there is an enormous responsibility on the Quality Assurance team to ensure & sign-off the quality of the data generated by the application. 

It is very hard to achieve this using manual testing and scheduling an automated validation helps achieve the timelines and ensure a high quality of the data with less efforts.

There are various tests in this library that would come in handy during the regression testing process. Since the project is implemented in Python, the learning curve is short when compared to the libraries that are available in Scala.

The documentation can be found in the following link:

https://github.com/IamVenkatesh/pyQualitas/wiki
cr-learn 0.1.2
A Library Provides Bunch of datasets to speed up your recsys learing.
Requires Python: >=3.6

# CR Learn

A Library Provides  datasets to speed up your recsys learing.

## Installation

```bash
pip install cr_learn
```

## Usage

```python
from cr_learn.ml_1m import load
from cr_learn.beibei import load
etc
```

# Dataset List

| Dataset Name    | Description           | Available in cr_learn |
|-----------------|-----------------------|------------------------|
| ml-1m           | MovieLens 1M dataset  | ✅                     |
| beibei          | Beibei dataset        | ✅                     |
| tmall           | Tmall dataset         | ✅                     |
| yelp            | Yelp dataset          | ❌                     |
| icjai           | ICJAI dataset         | ✅                     |
| amazon          | Amazon dataset        | ❌                     |
| lastfm          | Last.fm dataset       | ❌                     |
| yahoo           | Yahoo dataset         | ❌                     |
| library_things  | LibraryThings dataset | ✅                     |
simuk 0.2.0
Simulation based calibration and generation of synthetic data.
Requires Python: >=3.11

# Simulation Based Calibration

A [PyMC](http://docs.pymc.io) and [Bambi](https://bambinos.github.io/bambi/) implementation of the algorithms from:

Sean Talts, Michael Betancourt, Daniel Simpson, Aki Vehtari, Andrew Gelman: “Validating Bayesian Inference Algorithms with Simulation-Based Calibration”, 2018; [arXiv:1804.06788](http://arxiv.org/abs/1804.06788)

Many thanks to the authors for providing open, reproducible code and implementations in `rstan` and `PyStan` ([link](https://github.com/seantalts/simulation-based-calibration)).


## Installation

May be pip installed from github:

```bash
pip install simuk
```

## Quickstart

1. Define a PyMC or Bambi model. For example, the centered eight schools model:

    ```python
    import numpy as np
    import pymc as pm

    data = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])
    sigma = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])

    with pm.Model() as centered_eight:
        mu = pm.Normal('mu', mu=0, sigma=5)
        tau = pm.HalfCauchy('tau', beta=5)
        theta = pm.Normal('theta', mu=mu, sigma=tau, shape=8)
        y_obs = pm.Normal('y', mu=theta, sigma=sigma, observed=data)
    ```
2. Pass the model to the `SBC` class, and run the simulations. This will take a while, as it is running the model many times.
    ```python
    sbc = SBC(centered_eight,
            num_simulations=100, # ideally this should be higher, like 1000
            sample_kwargs={'draws': 25, 'tune': 50})

    sbc.run_simulations()
    ```
    ```python
    79%|███████▉  | 79/100 [05:36<01:29,  4.27s/it]
    ```

3. Plot the empirical CDF for the difference between prior and posterior. The lines
should be close to uniform and within the oval envelope.

    ```python
    sbc.plot_results()
    ```

![Simulation based calibration plots, ecdf](ecdf.png)


## What is going on here?

The [paper on the arXiv](http://arxiv.org/abs/1804.06788) is very well written, and explains the algorithm quite well.

Morally, the example below is exactly what this library does, but it generalizes to more complicated models:

```python
with pm.Model() as model:
    x = pm.Normal('x')
    pm.Normal('y', mu=x, observed=y)
```

Then what this library does is compute

```python
with my_model():
    prior_samples = pm.sample_prior_predictive(num_trials)

simulations = {'x': []}
for idx in range(num_trials):
    y_tilde = prior_samples['y'][idx]
    x_tilde = prior_samples['x'][idx]
    with model(y=y_tilde):
        idata = pm.sample()
    simulations['x'].append((idata.posterior['x'] < x_tilde).sum())
```
mdpfuzz 0.0.3
MDPFuzz Replication
Requires Python: >=3.5
Keywords: mdpfuzz

# Replicate of MDPFuzz
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15055468.svg)](https://doi.org/10.5281/zenodo.15055468)

This repository contains a re-implementation the policy testing framework [MDPFuzz](https://sites.google.com/view/mdpfuzz/evaluation-results?authuser=0), whose original code can be found [here](https://github.com/Qi-Pang/MDPFuzz).
This tool has been used in the paper *Replicability Study: Policy Testing with MDPFuzz*.

## Installation

You can install the package with `pip`:
```
pip install mdpfuzz
```
One can also want to install the package locally:
```
git clone https://github.com/QuentinMaz/MDPFuzz_Replication mdpfuzz
cd mdpfuzz
pip install -e .
```
In the latter case, don't forget to append the folder `mdpfuzz/` to your path.

## Usage

The *Fuzzer* class (`mdpfuzz/mdpfuzz.py`) provides functions for fuzzing with and without GMM guidance, as well as a simple random testing procedure.
It inputs an *Executor* object, which is responsible for generating and mutating inputs (also called *seeds*), loading the policy under test and executing test cases (i.e., running the policy with a given input).
As such, using the package involves 3 simple steps:
1. Implementing a *Executor* class for your use case.
2. Creating an *executor*, loading the model under test and instantiate a *fuzzer*.
3. Running the *fuzzer* (fuzzing - with or without GMM guidance - or Random Testing) with the testing budget you want!

### Example

In the file `dqn_mountain_car.py`, we test a DQN agent (learnt using the library [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)) for the [Mountain Car](https://gymnasium.farama.org/environments/classic_control/mountain_car/) environment.

#### Setup

Setup a virtual environment with, for instance, [conda](https://docs.conda.io/en/latest/):
```bash
conda create -n demo python=3.10.12
conda activate demo
pip install mdpfuzz
# install gymnasium and stable-baselines3 dependencies
pip install gymnasium==0.29.1
pip install stable-baselines3==2.2.1
```
Make sure to activate the virtual environment (`conda activate demo`) before executing the script!

Additionally, we provide the script as a [Jupyter notebook](https://jupyter.org/) in which with we detail each step of the demonstration.
If you use the notebook, install the following dependency in the virtual environment: `pip install ipykernel`.

The demonstration consists of:
1. Learning and saving the DQN agent (`dqn_mountain_car.zip`).
2. Testing the agent with a budget of 2500 test cases, with both Random Testing and MDPFuzz. The results of Random Testing are recorded in the current directory prefixed by `random_testing`, while the results of MDPFuzz are prefixed by `mdpfuzz`.
3. Plotting the evolution of the number of failures found over the test cases by the two methods in the file `failure_results_comparison_demo.png`.