semvec/pypi-packages huggingface dataset:
reinvent-scoring-rdkit 0.0.74
Scoring functions for Reinvent
Requires Python: >=3.7

# Introduction
This package contains the scoring functions for REINVENT.

# Installation
To install in REINVENT's environment either install from repo or use `pip install reinvent-scoring` for the latest
official release.

# Developing
## Setup environment
You can use Conda to create an environment with all the necessary packages installed.

```
$ conda env create -f reinvent_scoring
[...]
$ conda activate reinvent_scoring
```

## Run tests
The tests use the `unittest` package testing framework.  Before you can run the tests make sure that you have created a
`config.json`file in the `reinvent_scoring/configs` directory.  There is an example config in the same directory, which 
you can base your own config off of.  Make sure that you set `MAIN_TEST_PATH` to a non-existent directory; it is where 
temporary files will be written during the tests; if it is set to an existing directory, that directory will be removed 
once the tests have finished.

Some tests require a proprietary OpenEye license; you have to set up a few things to make the tests read your
license.  The simple way is to just set the `OE_LICENSE` environment variable to the path of the file containing the
license.  If you just want to set the license in the `reinvent_scoring` Conda environment, it is a bit more complicated,
but you only have to do it once.

```
(reinvent-scoring) $ cd $CONDA_PREFIX
$ mkdir -p etc/conda/activate.d
$ mkdir -p etc/conda/deactivate.d
```

Put the following in `etc/conda/activate.d/env_vars.sh`.

```
#!/bin/sh
export OE_LICENSE='</path/to/your/oe_license/file>'
```

And put the following in `etc/conda/deactivate.d/env_vars.sh`.

```
#!/bin/sh
unset OE_LICENSE
```

Once you have created the files, deactivate and re-activate the environment, and `echo $OE_LICENSE` should output the
path to the license file.

Once you have created and configured your environment, you can run unittests by running

```bash
python main_test.py --unittests
```

If you have a valid Open eye license and other dependencie configured, like Icolos and AZDOCK - 
you can also run integration tests, by running command (remember to submit this configuration, since the default one is test):

```bash
python main_test.py --integration --base_config <path to your configuration>
```

# Building
- Building: `python setup.py sdist bdist_wheel`
- Upload build to test: `python -m twine upload --repository testpypi dist/*`
- Upload build: `python -m twine upload dist/*`
ttable 0.7.0
Python toolkit for Boolean expressions
Requires Python: >=3.11
Keywords: boolean, sat, satisfiability, eda, bexpr

Synopsis
--------

tt (**t**\ ruth **t**\ able) is a library aiming to provide a toolkit for working with Boolean expressions and truth tables. Please see the `project site`_ for guides and documentation.

Installation
------------

tt is tested on the latest three major versions of CPython. You can get the latest release from PyPI with::

    pip install ttable

Features
--------

Parse expressions::

    >>> from tt import BooleanExpression
    >>> b = BooleanExpression('A impl not (B nand C)')
    >>> b.tokens
    ['A', 'impl', 'not', '(', 'B', 'nand', 'C', ')']
    >>> print(b.tree)
    impl
    `----A
    `----not
         `----nand
              `----B
              `----C

Evaluate expressions::

    >>> b = BooleanExpression('(A /\\ B) -> (C \\/ D)')
    >>> b.evaluate(A=1, B=1, C=0, D=0)
    False
    >>> b.evaluate(A=1, B=1, C=1, D=0)
    True

Interact with expression structure::

    >>> b = BooleanExpression('(A and ~B and C) or (~C and D) or E')
    >>> b.is_dnf
    True
    >>> for clause in b.iter_dnf_clauses():
    ...     print(clause)
    ...
    A and ~B and C
    ~C and D
    E

Apply expression transformations::

    >>> from tt import to_primitives, to_cnf
    >>> to_primitives('A xor B')
    <BooleanExpression "(A and not B) or (not A and B)">
    >>> to_cnf('(A nand B) impl (C or D)')
    <BooleanExpression "(A or C or D) and (B or C or D)">

Or create your own::

    >>> from tt import tt_compose, apply_de_morgans, coalesce_negations, twice
    >>> b = BooleanExpression('not (not (A or B))')
    >>> f = tt_compose(apply_de_morgans, twice)
    >>> f(b)
    <BooleanExpression "not not A or not not B">
    >>> g = tt_compose(f, coalesce_negations)
    >>> g(b)
    <BooleanExpression "A or B">

Exhaust SAT solutions::

    >>> b = BooleanExpression('~(A or B) xor C')
    >>> for sat_solution in b.sat_all():
    ...     print(sat_solution)
    ...
    A=0, B=0, C=0
    A=1, B=0, C=1
    A=0, B=1, C=1
    A=1, B=1, C=1

Find just a few::

    >>> with b.constrain(A=1):
    ...     for sat_solution in b.sat_all():
    ...         print(sat_solution)
    ...
    A=1, B=0, C=1
    A=1, B=1, C=1

Or just one::

    >>> b.sat_one()
    <BooleanValues [A=0, B=0, C=0]>

Build truth tables::

    >>> from tt import TruthTable
    >>> t = TruthTable('A iff B')
    >>> print(t)
    +---+---+---+
    | A | B |   |
    +---+---+---+
    | 0 | 0 | 1 |
    +---+---+---+
    | 0 | 1 | 0 |
    +---+---+---+
    | 1 | 0 | 0 |
    +---+---+---+
    | 1 | 1 | 1 |
    +---+---+---+

And `much more`_!

License
-------

tt uses the `MIT License`_.


.. _MIT License: https://opensource.org/licenses/MIT
.. _project site: https://tt.brianwel.ch
.. _bool.tools: http://www.bool.tools
.. _much more: https://tt.brianwel.ch/en/latest/user_guide.html
image-processing-felipeluiz93teste 0.0.4
image Processing Package using skimage
Requires Python: >=3.5

# image_processing

Description. 
The package image_processing is used to:
	Processing: 
		- Histrogram matching 
		- Structural similarity
		- Resize image
	Utils:
		- Read image
		- Size image
		- Plot image 
		- Plot result 
		- Plot histogram	

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image_processing

```bash
pip install image_processing
```

## Usage

```python
from image_processing.module1_name import file1_name
file1_name.my_function()
```

## Author
Felipe

## License
[MIT](https://choosealicense.com/licenses/mit/)
mcp-meituan-ip 0.1.1
这是一个根据美团接口查询位置的mcp服务器
Requires Python: >=3.11

# mcp-meituan-ip MCP server



## 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": {
    "mcp-meituan-ip": {
      "command": "uv",
      "args": [
        "--directory",
        "D:\idea-work\mcp-meituan-ip",
        "run",
        "mcp-meituan-ip"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "mcp-meituan-ip": {
      "command": "uvx",
      "args": [
        "mcp-meituan-ip"
      ]
    }
  }
  ```
</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 D:\idea-work\mcp-meituan-ip run mcp-meituan-ip
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
grep-ast 0.9.0
A tool to grep through the AST of a source file

# grep-ast

Grep source code files and see matching lines with
useful context that show how they fit into the code.
See the loops, functions, methods, classes, etc
that contain all the matching lines.
Get a sense of what's inside a matched class or function definition.
You see relevant code from every layer of the
abstract syntax tree, above and below the matches.

By default, grep-AST recurses the current directory to search all source code files.
It respects `.gitignore`, so it will usually "do the right thing" in most repos
if you just do `grep-ast <regex>` without specifying any filenames.

You can also invoke `grep-ast` as `gast` for convenience.

Grep-AST is built with [tree-sitter](https://tree-sitter.github.io/tree-sitter/) and
[tree-sitter-languages](https://github.com/grantjenks/py-tree-sitter-languages).
So it supports a lot of popular [code languages](https://github.com/paul-gauthier/grep-ast/blob/main/grep_ast/parsers.py).

## Install

```bash
python -m pip install git+https://github.com/paul-gauthier/grep-ast.git
```

## Usage

Basic usage:

```bash
grep-ast [pattern] [filenames...]
```

Full options list:

```
usage: grep_ast.py [-h] [-i] [--color] [--no-color] [--encoding ENCODING] [--languages] [--verbose]
                   [pat] [filenames ...]

positional arguments:
  pat                  the pattern to search for
  filenames            the files to display

options:
  -h, --help           show this help message and exit
  -i, --ignore-case    ignore case distinctions
  --color              force color printing
  --no-color           disable color printing
  --encoding ENCODING  file encoding
  --languages          print the parsers table
  --verbose            enable verbose output
```

## Examples

Here we search for **"encoding"** in the source to this tool.
These results mainly highlight how `grep-ast`
shows you how the matches fit into the code base.

<img src="assets/screenshot-encoding.svg" alt="aider screencast">

Here we search for **"TreeContext"** in the source to this tool.
These results mainly highlight how `grep-ast`
helps you understand the *contents* of a matching
named code block (class, function, method, etc).

<img src="assets/screenshot-TreeContext.svg" alt="aider screencast">