semvec/pypi-packages huggingface dataset:
mcp-excel 0.1.2
MCP server to give client the ability to read Excel files
Requires Python: >=3.12

# mcp-excel

MCP server to give client the ability to read Excel files

# Usage

For this MCP server to work, add the following configuration to your MCP config file:

```json
{
  "mcpServers": {
    "excel": {
      "command": "uv",
      "args": [
        "run",
        "python",
        "-m",
        "mcp_excel"
      ]
    }
  }
}
```

## Features

- Read Excel files and get their content as pandas DataFrames
- Extract Excel properties including:
  - Data validation rules
  - Dropdown lists
  - Merged cells
  - Hidden rows and columns
- Comprehensive error handling
- Full test coverage

## Requirements

- Python >= 3.12
- pandas >= 2.2.3
- openpyxl >= 3.1.5
- mcp[cli] >= 1.3.0

## Development

1. Clone the repository
2. Install development dependencies:
   ```bash
   pip install -e ".[dev]"
   ```
3. Run tests:
   ```bash
   pytest
   ```

## License

MIT License
bpsk-mod 0.0.0
BPSK modulation and demodulation functions

BPSK Modulation and Demodulation
===============================

This package provides functions for BPSK modulation and demodulation.

Installation
------------

You can install the package via pip:

.. code:: bash

    pip install bpsk_mod

Usage
-----

Here is an example of how to use the package:

```python
import numpy as np
from bpsk_mod.modulation import modulator, demodulator

# Parameters
N = 1000  # Number of bits
L = 16    # Upsampling factor

# Generate random binary message
bit = np.random.randint(0, 2, N)

# Modulate the message
modulated_signal, t = modulator(bit, L)

# Demodulate the signal (e.g., with noise)
received_signal = modulated_signal  # Assume no noise for simplicity
demodulated_bits = demodulator(received_signal, L)

# Print the demodulated bits
print("Demodulated bits:", demodulated_bits)
ccfg 0.0.4
A Python library for managing hierarchical configurations using a class-based approach.
Requires Python: >=3.6
Keywords: config, class, pydantic, json

# ccfg

A Python library for managing hierarchical configurations using a class-based approach.

## Features

- Define configuration hierarchies using Python classes
- Access configuration hierarchically using dot notation, enabling IDE autocompletion
- Access to non-existent paths returns None instead of raising errors
- Automatically convert between configuration classes and dictionaries
- Support for multiple serialization formats (JSON, TOML, YAML)
- Simple file-based storage and retrieval

## Installation

```bash
pip install ccfg
```

### Optional Dependencies

For additional serialization format support:
- For TOML support: `pip install toml`
- For YAML support: `pip install pyyaml`

## Usage Example

Below is a comprehensive example demonstrating the main features:

```python
from ccfg import CCFG

class ApplicationConfig(CCFG):
    # Custom path for file storage
    path = "configs/app_settings.json"

    # No explicit name, will use class name "ApplicationConfig" as default

    class Database:
        # Custom name for this section
        name = "DatabaseSettings"

        class Connection:
            # No explicit name, will use "Connection" by default
            value = "postgresql://user:password@localhost:5432/mydb"

        class Pooling:
            name = "ConnectionPool"
            value = {"max_connections": 10, "timeout": 30}

    class Logging:
        # Using default name "Logging"

        class Level:
            value = "INFO"

        class Output:
            name = "OutputPath"
            value = "/var/log/app.log"

    class Features:
        # Using a list for complex values
        value = ["authentication", "api", "admin_panel"]


# Convert to dictionary
config_dict = ApplicationConfig.to_dict()
print(config_dict)
# Output:
# {
#   "ApplicationConfig": {
#     "DatabaseSettings": {
#       "Connection": "postgresql://user:password@localhost:5432/mydb",
#       "ConnectionPool": {"max_connections": 10, "timeout": 30}
#     },
#     "Logging": {
#       "Level": "INFO",
#       "OutputPath": "/var/log/app.log"
#     },
#     "Features": ["authentication", "api", "admin_panel"]
#   }
# }

# Save to file using the configured path
ApplicationConfig.dump()  # Saves to configs/app_settings.json

# Save to a different file in YAML format
ApplicationConfig.dump(form="yaml", path="configs/app_config.yaml")

# Load configuration
ApplicationConfig.load()  # Loads from configs/app_settings.json

# Access configuration values
db_connection = ApplicationConfig.Database.Connection.value
log_level = ApplicationConfig.Logging.Level.value
features = ApplicationConfig.Features.value

print(f"Database connection: {db_connection}")
print(f"Log level: {log_level}")
print(f"Enabled features: {', '.join(features)}")
```

### Supported Serialization Formats

- JSON (default)
- TOML
- YAML

## License

MIT