semvec/pypi-packages huggingface dataset:
sagar-nueron-gpt2 0.1.8
A GPT-2 implementation for training and inference in pytorch
Requires Python: >=3.8
Keywords: gpt2, machine learning, nlp



##  How to Run

###  Language & Framework

* **Language**: Python
* **Framework**: PyTorch

---

###  Installation

Make sure you have Python installed, then run the following commands to set up the environment:

```bash
pip install -i https://test.pypi.org/simple/ sagar-nueron-gpt2==0.1.7
pip install torch
pip install tiktoken
```

---

###  Train the Model

To train and save your GPT-2 model weights, run the following:

```python
from sagar_nueron_gpt2.TrainAndSaveGptWeights import Execute

exe = Execute()
exe.execute()
```

---

###  Inference from Trained Model

To run inference using the model you trained:

```python
from sagar_nueron_gpt2.inference_model import Inferencing

exe = Inferencing()
exe.inference()
```

---
VeloxEngine 0.1.2
A minimal SDL2-based game engine in Python for building 2D games quickly.
Requires Python: >=3.7


VeloxEngine is a lightweight Python game engine built on SDL2, designed to help you create
2D games with ease and speed.

Pixnox Studio's : https://github.com/Pixnox-Studio

Docs:
https://pixnox-studio.github.io/Velox-Web/
sbcli-alsh 18.0.74
CLI for managing SimplyBlock cluster


# SBCLI (SimplyBlock CLI)

Simplyblock provides a feature-rich CLI (command line interface) to deploy SimplyBlock Cluster and to manage the SimplyBlock Control plane

## Install

The CLI can be installed using pypi package [sbctl](https://pypi.org/project/sbctl/)

```
pip install --upgrade sbctl
```

# Components

## Simply Block Core
Contains core logic and controllers for the simplyblock cluster

## Simply Block CLI
The list of all the available CLI options can be here [CLI docs](./simplyblock_cli/README.md)

## SimplyBlock Web API

Web app that provides API to manage the cluster. More about this in [README.md](./simplyblock_web/README.md)


### local development

FoundationDB requires a client library (libfdb_c.dylib) for the Python bindings to interact with the database.
Depending on the OS architecture, please install the appropriate version from the official github repo

```
wget https://github.com/apple/foundationdb/releases/download/7.3.3/FoundationDB-7.3.3_arm64.pkg
```
setup the code on a management node and the webApp code can be developed by building the `docker-compose-dev.yml` file.

```
sudo docker compose -f docker-compose-dev.yml up --build -d
```
Energytool 0.1.0
Edit IDF files run EnergyPlus and process results
Requires Python: >=3.10


# Energytool

<p align="center">
  <img src="https://raw.githubusercontent.com/BuildingEnergySimulationTools/energytool/main/logo_energytool.svg" alt="Energytool" width="200"/>
</p>


[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
![Static Badge](https://img.shields.io/badge/python-3.10_%7C_3.12-blue)
[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)


Python module to wrap EnergyPlus for CorrAI :
- <code>Building</code> class to simulate HVAC systems through pre-process and post process methods
- Basic HVAC model
- Modifier function for parametric simulation
- Allows Pandas <code>DataFrame</code> as boundary conditions
DL-Track-US 0.3.0
Automatic analysis of logitudinal muscle ultrasonography images
Requires Python: >=3.10

# DL_Track_US

[![DOI](https://joss.theoj.org/papers/10.21105/joss.05206/status.svg)](https://doi.org/10.21105/joss.05206)

The DL_Track_US package provides an easy to use graphical user interface (GUI) for deep learning based analysis of muscle architectural parameters from longitudinal ultrasonography images of human lower limb muscles. Please take a look at our [documentation](https://paulritsche.github.io/DL_Track_US/) for more information (note that aggressive ad-blockers might break the visualization of the repository description as well as the online documentation).
This code is based on a previously published [algorithm](https://github.com/njcronin/DL_Track) and replaces it. We have extended the functionalities of the previously proposed code. The previous code will not be updated and future updates will be included in this repository. 

## Getting started

For detailled information about installaion of the DL_Track_US python package we refer you to our [documentation](https://paulritsche.github.io/DL_Track_US/). There you will finde guidelines not only for the installation procedure of DL_Track_US, but also concerding conda and GPU setup.

## Quickstart

Once installed, DL_Track_US can be started from the command prompt with the respective environment activated:

``(DL_Track_US0.3.0) C:/User/Desktop/ python -m DL_Track_US`` 

In case you have downloaded the executable, simply double-click the DL_Track_US icon.

Regardless of the used method, the GUI should open. For detailed the desciption of our GUI as well as usage examples, please take a look at the [user instruction](https://paulritsche.github.io/DL_Track_US/). An illustration of out GUI start window is presented below. It is here where users must specify input directories, choose the preferred analysis type, specify the analysis parameters or train thrain their own neural networks based on their own training data. 

![GUI](./DL_Track_US/docs/md_graphics/DLTrack_mainUI.png)

## Testing

We have not yet integrated unit testing for DL_Track_US. Nonetheless, we have provided instructions to objectively test whether DL_Track_US, once installed, is functionable. To perform the testing procedures yourself, check out the [test instructions](https://paulritsche.github.io/DL_Track_US/).

## Code documentation 

In order to see the detailled scope and description of the modules and functions included in the DL_Track_US package, you can do so either directly in the code, or in the [Documentation](https://paulritsche.github.io/DL_Track_US/) section of our online documentation.

## Community guidelines

Wheter you want to contribute, report a bug or have troubles with the DL_Track_US package, take a look at the provided [instructions](https://paulritsche.github.io/DL_Track_US/) how to best do so.
mcp-python-client 0.1.9
Python client for interacting with MCP servers and LLMs
Requires Python: >=3.10

# MCP Python Client

A reusable Python client for interacting with MCP (Machine Conversation Protocol) servers and LLMs.

## Features

- Connect to and interact with multiple MCP servers
- Call tools provided by MCP servers
- Process user queries using various LLM models via LiteLLM
- Support for synchronous and asynchronous operations
- Streaming response support

## Installation

```bash
pip install mcp-python-client
```

## Quick Start

```python
import asyncio
from mcp_python_client import MCPClient

async def main():
    # Create a client with your preferred LLM settings
    client = MCPClient(
        model="anthropic/claude-3-sonnet-20240229",
        api_key="your_api_key_here"  # Or set via env var
    )
    
    # Connect to MCP servers defined in your config
    await client.connect_to_all_servers()
    
    # Process a query
    query = "What is the current weather in New York?"
    
    # Stream response
    async for chunk in client.aprocess_query(query):
        print(chunk, end="", flush=True)
    
    # Clean up
    await client.cleanup()

# Run the example
asyncio.run(main())
```

## Configuration

The client looks for a configuration file in the following locations:

1. Path specified when creating the client
2. `~/.config/mcp-client/config.json`
3. `~/.mcp-client.json`
4. `./mcp-client.json`
5. `./config.json`

Example configuration file:

```json
{
  "mcpServers": {
    "shell-server": {
      "command": "mcp-shell-server",
      "args": ["--use_cache"],
      "env": {
        "SHELL_SERVER_CACHE_DIR": "/tmp/shell-server-cache"
      }
    },
    "python-server": {
      "command": "mcp-python-server",
      "args": []
    }
  }
}
```

## Advanced Usage

See the [documentation](https://github.com/yourusername/mcp-python-client) for more advanced usage examples and API details.

## Publishing
``` 
uv build
uv publish
```
## License

MIT
multifile-ida-plugin 0.1.0
Example IDA Plugin with multiple files
Requires Python: >=3.9

# multifile-ida-plugin

An example IDA plugin that uses multiple files.

```
 multifile-ida-plugin
 ├── pyproject.toml
 ├── README.md
 └── src
     └── multifile_ida_plugin
         ├── __init__.py
         └── plugin
             └── __init__.py
```

There is a library `multifile_ida_plugin` with arbitrary code
 (in this case, a function `multifile_ida_plugin.hello`).

```py
def hello():
  print("hello from Python (multifile)")
```

Then, there's an IDA plugin found in `multifile_ida_plugin.plugin`
 which corresponds to the file `src/multifile_ida_plugin/plugin/__init__.py`
 and contains the `PLUGIN_ENTRY` function expected by IDA.


```py
import idaapi
import multifile_ida_plugin

class multifile_plugmod_t(idaapi.plugmod_t):
    def run(self, arg):
        multifile_ida_plugin.hello()
        return 0

class multifile_plugin_t(idaapi.plugin_t):
    ...
    def init(self):
        return multifile_plugmod_t()


def PLUGIN_ENTRY():
    return multifile_plugin_t()
```

The plugin invokes a routine from the library code, demonstrating how not all of the plugin code
 has to be bundled into the primary plugin file.

The `pyproject.toml` shows how to specify the location of the plugin:

```toml
[project.entry-points.'idapro.plugins']
idapython = "multifile_ida_plugin.plugin"
```

## publishing

Published to PyPI as `multifile-ida-plugin` via the GH Action workflow [publish-multifile-ida-plugin.yml](/../../github/workflows/publish-multifile-ida-plugin.yml).
coverage2sketch 0.1.0
A tool to extract "sketches" of Python source files based on coverage data.
Requires Python: >=3

# Coverage2Sketch

This code implements a tool to extract "sketches" of Python source files based on coverage data.

In a "sketch":

- Only code that was executed (covered) remains
- Uncovered code is replaced with `...` placeholders
- Consecutive placeholders are collapsed
- Comments and docstrings are removed

This is helpful for:

*   **Understanding Test Coverage:** Quickly visualize which parts of your code are actually executed during testing.
*   **Code Visualization:**  Generate a text-based representation of the code's execution flow.
*   **Debugging:**  Pinpoint areas of code that are not reached or have potential issues.
*   **Code Review:**  Assist in identifying dead code or areas requiring more thorough testing.

## Features

1. **Version Compatibility Handling**:
   - Supports Python 3+
   - Uses different AST node types (`Ellipsis` vs `Constant`) depending on Python version (pre-3.8 vs 3.8+)
   - Uses `astor.to_source` for Python < 3.9 and `ast.unparse` for Python ≥ 3.9

## Installation

```bash
pip install coverage2sketch
```

## Usage as an Executable Module

When used as an executable module (i.e., `python -m coverage2sketch -c .coverage`), the tool outputs Markdown-formatted results showing:

- Each measured file path in backticks
- The code sketch in a Python code block

1. First generate coverage data by running your tests with coverage:
   ```bash
   coverage run -m pytest  # or whatever test command you use
   ```

2. Then generate sketches from the coverage data:
   ```bash
   python -m coverage2sketch -c .coverage | tee sketches.md  # Save to file
   ```

### Command Line Arguments

| Argument | Description |
|----------|-------------|
| `-c`/`--coverage-file` | Path to the `.coverage` data file (default: `.coverage`) |

### Example Output

`/path/to/module.py`:

```python
def covered_function():
    print("This was executed")
    ...

def another_covered_function():
    x = 1
    return x
```

`/path/to/other_module.py`:

```python
class TestedClass:
    def method(self):
        return True
    ...
```

## Usage as a Package

When used as a a package, the function `extract_sketches(coverage_file_path: str) -> Dict[str, str]` returns a dictionary with file path as key and execution trace as value.

```python
from coverage2sketch import extract_sketches

# Example usage
sketches = extract_sketches('/some/directory/.coverage')

# Output the sketches for each module
for file_path, sketch in sketches.items():
    print('File: %s' % file_path)
    print(sketch)
    print('-' * 20)
```

## Contributing

Contributions are welcome!  Please submit pull requests or open issues on [GitHub](<your_github_repo_url>).  (Replace with your actual repository URL.)

## License

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