semvec/pypi-packages huggingface dataset:
mcp-jetbrains-proxy 0.1.1.dev30
MCP proxy between LLM and JetBrains IDE
Requires Python: >=3.11
Keywords: ide, jetbrains, llm, mcp, proxy

# MCP JetBrains Proxy

[![PyPI version](https://badge.fury.io/py/mcp-jetbrains-proxy.svg)](https://badge.fury.io/py/mcp-jetbrains-proxy)
[![Python Versions](https://img.shields.io/pypi/pyversions/mcp-jetbrains-proxy.svg)](https://pypi.org/project/mcp-jetbrains-proxy/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![CI/CD](https://github.com/leobuskin/mcp_jetbrains_proxy/actions/workflows/ci.yml/badge.svg)](https://github.com/leobuskin/mcp_jetbrains_proxy/actions/workflows/ci.yml)

A Python implementation of Model Context Protocol (MCP) proxy for JetBrains IDEs. This package provides a bridge between LLM services and JetBrains IDEs using the MCP protocol.

Check out:   
[Original MCP JetBrains Proxy](https://github.com/JetBrains/mcp-jetbrains)  
[MCP JetBrains Server](https://github.com/JetBrains/mcp-server-plugin)  


## Installation

```bash
pip install mcp_jetbrains_proxy
```

## License

MIT
typemedaddy 0.8
Derives type hints from data captured during runtime. Updates source files with type hints. USE SOURCE CONTROL before upating in-place!!!!

# CAUTION!!!
This lib will OVERWRITE YOUR SOURCE FILES! ( It creates backup files before it does )
Use SOURCE CONTROL before running this !!!!

# What
Inspects code at runtime, derives types from arguments and updates in-place source files with detected type hints and required imports.

# Requirements
At minimum 3.5 - I haven't tested properly.
Ideally use 3.9 or higher ( This lib supports both Union and '|' operators)

# Install
```bash
pip install typemedaddy
```

# Usage
```python
from typemedaddy.typemedaddy import trace, type_it_like_its_hot

def foo(i, x):
    return i + x

with trace() as data:
    foo(1, 2)
"""
update_files: updates source files in place with new types, this is a destructive action! 
            If False, results json will be saved to a file with unix timestamp. 
            Default = False.
backup_file_suffix: creates backup files and adds suffix to them.
            Example: backup_file_suffix="bak" will create `foo.py.bak`. 
            Default = "bak"
dump_intermediate_data: will create 3 files with intermediate data used to derive final results. 
            Default = False
"""
type_it_like_its_hot(data, update_files=True, backup_file_suffix="bak", dump_intermediate_data=False)
```

# Result
```python
def foo(i: int,
        x: str = 'x') -> int:
    return i
```
django-js-lib-select2 4.0.13.0
Select2 for Django
Requires Python: >=3.8

# Select2 for Django

[Select2](https://select2.org/) packaged in a Django reusable app.

This package includes the original JS and CSS files from the library.


## Installation

    pip install django-js-lib-select2

## Usage

1. Add `"js_lib_select2"` to your `INSTALLED_APPS` setting like this::

       INSTALLED_APPS = [
           ...
           "js_lib_select2",
           ...
       ]

2. In your template use:
   
       {% load static %}
   
   ...
   
       <link rel="stylesheet" href="{%static "js_lib_select2/css/select2.css" %}">

   ...
   
       <script src="{%static "js_lib_select2/js/select2.js" %}"></script>
triangle-cubature 1.2.0
cubature rules on triangles
Requires Python: >=3.9.18

# Triangle Cubature Rules
This repo serves as a collection of well-tested triangle cubature rules,
i.e. numerical integration schemes for integrals of the form

$$
\int_K f(x, y) ~\mathrm{d}x ~\mathrm{d}y,
$$

where $K \subset \mathbb{R}^2$ is a triangle.
All cubature rules are based on [1].

## Usage
Using the cubature schemes is fairly simple.

```python
from triangle_cubature.cubature_rule import CubatureRuleEnum
from triangle_cubature.integrate import integrate_on_mesh
from triangle_cubature.integrate import integrate_on_triangle
import numpy as np

# specifying the mesh
coordinates = np.array([
  [0., 0.],
  [1., 0.],
  [1., 1.],
  [0., 1.]
])

elements = np.array([
  [0, 1, 2],
  [0, 2, 3]
], dtype=int)


# defining the function to be integrated
# NOTE the function must be able to handle coordinates as array
# of shape (N, 2)
def constant(coordinates: np.ndarray):
    """returns 1"""
    return np.ones(coordinates.shape[0])


# integrating over the whole mesh
integral_on_mesh = integrate_on_mesh(
    f=constant,
    coordinates=coordinates,
    elements=elements,
    cubature_rule=CubatureRuleEnum.MIDPOINT)

# integrating over a single triangle, e.g.
# in this case, the "first" element of the mesh
integral_on_triangle = integrate_on_triangle(
    f=constant,
    triangle=coordinates[elements[0], :],
    cubature_rule=CubatureRuleEnum.MIDPOINT)

print(f'Integral value on mesh: {integral_on_mesh}')
print(f'Integral value on triangle: {integral_on_triangle}')

```

## Available Rules
The available cubature rules can be found in `triangle_cubature/cubature_rule.py`.

- `CubatureRuleEnum.MIDPOINT`
  - degree of exactness: 1
  - Ref: [1]
- `CubatureRuleEnum.LAUFFER_LINEAR`
  - degree of exactness: 1
  - Ref: [1]
- `CubatureRuleEnum.SMPLX1`
  - degree of exactness: 2
  - Ref: [1]
- `CubatureRuleEnum.DAYTAYLOR`
  - degree of exactness: 6
  - Ref: [2]


## (Unit) Tests
To run auto tests, you do
```sh
python -m unittest discover tests/auto/
```

> The unit tests use `sympy` to verify the degree of exactness of the
> implemented cubature rules, i.e. creates random polynomials $p_d$ of the 
> expected degree of exactness $d$ and compares the exact result of
> $\int_K p_d(x, y) ~\mathrm{d}x ~\mathrm{d}y$ to the value obtained
> with the cubature rule at hand.

## References
- [1] Stenger, Frank.
    'Approximate Calculation of Multiple Integrals (A. H. Stroud)'.
    SIAM Review 15, no. 1 (January 1973): 234-35.
    https://doi.org/10.1137/1015023. p. 306-315
- [2] D.M. Day and M.A. Taylor 
    'A new 11 point degree 6 formula for the triangle',
    PAMM Proc. Appl. Math. Mech. 7 1022501-1022502 (2007).