semvec/pypi-packages huggingface dataset:
ecida 0.0.33
The ECiDA Python SDK to make things easier.
Requires Python: >=3.0

# ECIDA
The EcidaModule package is a Python module designed to facilitate deployment and communication between components in a distributed system. This package provides various functionalities including Kafka message handling, environment variable checking, and directory management.

## How to Use

1. ### Importing the package

    To use the EcidaModule in your Python program, first, you will need to import the EcidaModule class from the package:

    ```python
    from Ecida import EcidaModule
    ```

2. ### Create an ECiDA Module
    Define a module with this signature
    ```python
    def create_module() -> EcidaModule:
        M = EcidaModule("MODULE_NAME", "MODULE_VERSION")
        # ADD MODULE INPUTS/OUTPUTS HERE
        ...
    return M
    ```

3. ### Add inputs and outputs
    Use the following syntax for adding input and output to module. You can add as many I/O as required.
    ``` python
    # ADD STREAMING INPUT WITH 
    M.add_input("INPUT_NAME", "string")
    # ADD STREAMING OUTPUT 
    M.add_output("OUTPUT_NAME", "string")
    # ADD INPUT DIRECTORY FOR FILE USE 
    M.add_input_directory("INPUT_DIRECTORY_NAME")
    # ADD OUTPUT DIRECTORY FOR FILE USE 
    M.add_output_directory("OUTPUT_DIRECTORY_NAME")
    # ADD INPUT DIRECTORY PRELOADING FROM GIT FOR FILE USE
    M.add_input_from_git("INPUT_DIRECTORY_NAME", "GIT_REPOSITORY", "DIRECTORY/PATH/IN/GIT")
    ```


4. ## Entry Point

    Use the following boiler-plate as the entry-point to your code.

    ```python
    if __name__ == "__main__":
        M = create_module()
        M.initialize()
        main(M)
    ```

    and for the main function use the following signature:
    
    ```python
    def main(M: EcidaModule):    
        #YOUR LOGIC COMES HERE
    ```


## Example python file
An example template for the modules.
```python
from Ecida import EcidaModule

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


def create_module() -> EcidaModule:
    M = EcidaModule("MODULE_NAME", "MODULE_VERSION")
    # ADD MODULE INPUTS/OUTPUTS HERE

    return M

def main(M: EcidaModule):    
    print(f"START MODULE {M.name}:{M.version}")
    # LOGIC COMES HERE
      


if __name__ == "__main__":
    M = create_module()
    M.initialize()
    main(M)
```

### NOTES
A python file can contain no more than one one module, since the module creation happens through using create_module() function with exact same signature.
pythonwhat 2.30.1
Submission correctness tests for Python

# pythonwhat

[![Build Status](https://travis-ci.org/datacamp/pythonwhat.svg?branch=master)](https://travis-ci.org/datacamp/pythonwhat)
[![PyPI version](https://badge.fury.io/py/pythonwhat.svg)](https://badge.fury.io/py/pythonwhat)
[![Documentation Status](https://readthedocs.org/projects/pythonwhat/badge/?version=stable)](http://pythonwhat.readthedocs.io/en/stable/?badge=stable)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fdatacamp%2Fpythonwhat.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fdatacamp%2Fpythonwhat?ref=badge_shield)

Verify Python code submissions and auto-generate meaningful feedback messages. Originally developed for Python exercises on DataCamp for so-called Submission Correctness Tests, but can also be used independently.

- New to teaching on DataCamp? Check out https://instructor-support.datacamp.com
- To learn what SCTs are and how they work, visit [this article](https://instructor-support.datacamp.com/courses/course-development/submission-correctness-tests) specifically.
- For a complete overview of all functionality inside pythonwhat and articles about what to use when, consult https://pythonwhat.readthedocs.io.

## Installation

```bash
# latest stable version from PyPi
pip install pythonwhat

# latest development version from GitHub
pip install git+https://github.com/datacamp/pythonwhat
```

## Demo

To experiment locally, you can use `setup_state()` and write SCTs interactively.
The code throws an error when the underlying checks fail.

```python
# make all checking functions available
from pythonwhat.test_exercise import prep_context
_, ctxt = prep_context()
globals().update(ctxt)

# initialize state with student and solution submission
from pythonwhat.test_exercise import setup_state
setup_state(stu_code = "x = 5", sol_code = "x = 4")

Ex().check_object('x')
# No error: x is defined in both student and solution process

Ex().check_object('x').has_equal_value()
# TestFail: Did you correctly define the variable `x`? Expected `4`, but got `5`.

# Debugging state
Ex()._state               # access state object
dir(Ex()._state)          # list all elements available in the state object
Ex()._state.student_code  # access student_code of state object
```

To learn how to include an SCT in a DataCamp course, visit https://instructor-support.datacamp.com.

## Run tests

```bash
pyenv local 3.12.7
pip3.12 install -r requirements-test.txt
pip3.12 install -e .
pytest
```

## Contributing

Bugs? Questions? Suggestions? [Create an issue](https://github.com/datacamp/pythonwhat/issues/new), or [contact us](mailto:content-engineering@datacamp.com)!

## License

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fdatacamp%2Fpythonwhat.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fdatacamp%2Fpythonwhat?ref=badge_large)
hw-weather-server 0.1.0
search weather by location
Requires Python: >=3.12

# hw-weather-server MCP server

search weather by location

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "hw-weather-server": {
      "command": "uv",
      "args": [
        "--directory",
        "G:\mcp\hw-weather-server",
        "run",
        "hw-weather-server"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "hw-weather-server": {
      "command": "uvx",
      "args": [
        "hw-weather-server"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory G:\mcp\hw-weather-server run hw-weather-server
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
bbqec 1.4
A package for quantum error correction with bivariate bicycle codes
Requires Python: >=3.8

# QEC Bivariate Bicycle Codes

A Python package for quantum error correction using bivariate bicycle codes.

## Installation

```bash
pip install bbqec
```

## Usage

### Basic Usage Example

```python
from bbqec import BBCode

# Create a new BBCode
l = 8
m = 10
A = ['i', 'x1', 'y7', 'x6.y5']
B = ['x0', 'x5', 'y6.x7', 'x.y5']

code = BBCode(l, m, A, B)

# Find the parameters of the code
# distance_method = 4 uses bposd to calculate the distance (recommended)
n, k, d = code.generate_bb_code(distance_method=4)
print(f"Code parameters: [{n}, {k}, {d}]")

# Get parity-check matrices
H_x, H_z = code.create_parity_check_matrices()

# Create Tanner Graph
G = code.make_graph()
```

### Optimized Version for Multiple Codes

```python
from bbqec import BBCodeOptimised
from bbqec.helpers import ProposeParameters

# Set up parameters
l = 10
m = 8
num_codes = 50

# Create an instance of BBCodeOptimised
code = BBCodeOptimised(l, m)

# Help generate random A and B expressions
parameters = ProposeParameters(l, m)

# Generate codes
for _ in range(num_codes):
    A = parameters.draw_bivariate_monomials(num_monomials=3)
    B = parameters.draw_bivariate_monomials(num_monomials=3)
    
    code.set_expressions(A_expression=A, B_expression=B)
    n, k, d = code.find_distance(distance_method=4)
    
    print(f"Code parameters: [{n}, {k}, {d}]")
```

## Documentation

For detailed documentation, usage examples, and more information about the API:

*   Visit the [GitHub repository](https://github.com/vanshjjw/qec-bivariate-bicycle).
*   Check out the [Usage Guide (src/usage.md)](https://github.com/vanshjjw/qec-bivariate-bicycle/blob/master/src/usage.md).

## Features

*   Create and analyze bivariate bicycle quantum error correction codes
*   Multiple distance calculation methods
*   Optimized implementations for generating multiple codes
*   Tanner graph representation of codes
*   Polynomial helpers for working with bivariate polynomials
dv-fastapi 0.1.0
DV FastAPI example
Requires Python: >=3.9

# DV FastAPI

## 1. Installation
```bash
pip install dv-fastapi
```

## 2. Create a `.env` file with the following variables:

- `UVICORN_PORT` — Port for running FastAPI via Uvicorn. Default: `8000`
- `MERCHANT_HOST` — Deployed merchant host address. Default: `demo.dv.net`
- `STORE_UUID` — UUID of the store project. Can be `null` if the store uses the API.
- `STORE_API_KEY` — Store API key. Can be `null` if the store payment form **does not** use the API.
- `WEBHOOK_SECRET_KEY` — Secret key for verifying webhook notifications (payment received, mempool payment received, payment finished).
- `FORCE_NO_API` — Determines API usage mode:  
  - If `true`:  
    - `STORE_API_KEY=null`  
    - `STORE_UUID` **must** be provided  
  - If `false`:  
    - `STORE_API_KEY` **must** be provided  
    - `STORE_UUID=null`  
  Default: `true`

## 2. Set webhook URLs in your store project settings:

- **Merchant payment received**:  
  `https://{fastapi_host_address}/webhook_payment_received`

- **Mempool payment received**:  
  `https://{fastapi_host_address}/webhook_mempool_payment_pending`

- **Payment finished (received on wallet)**:  
  `https://{fastapi_host_address}/webhook_payment_finished`

## 3. Getting Started

Via CLI:

```bash
dv_fastapi
```

Or python script:

```python
from dv_fastapi import run

run()
```