semvec/pypi-packages huggingface dataset:
calc-files-control-sum 1.1.4
Calculate files control sum
Requires Python: <3.12,>=3.7.2

# Utility to Calc Files Control Sum (CFCS) in specified folder.

File checksum information is written to stdout.
To later check the files for changes, you need to save this information 
to a file by redirecting the output to a file (> filename.ext)

## Command string parameters:
  - -h, --help            show this help message and exit
  - -c CHECK_FILE, --check_file CHECK_FILE
                        Name of the source file of checksums for checking
                        files. Type: cfcs [opt] > filename.ext to produce
                        check file filename.ext in current working dir!
  - -s SRC, --src SRC     Folder in which checksums of files are calculated.
  - -a ALG, --alg ALG     Algorithm for calculating the checksum. For example
                        MD5, SHA1, SHA224, SHA256, SHA384, SHA512. Default
                        value: md5
  - -e EXT, --ext EXT     Pattern string for filename matching check! Filters
                        out files subject to checksum calculation. For
                        example: "*.zip,*.rar,*.txt"
  
## Example: 
- ```cfcs --src=/home/username --alg=sha1 --ext="*.rar,*.avi,*.bmp" (writing checksum information to stdout).```
- ```cfcs --src=/home/username --alg=sha1 --ext="*.zip,*.7z,*.mp4" > control_sum_filename.ext (writing checksum information to file).```
- ```cfcs --check_file==/home/previously_created_file.ext  (check files in folder).```

## Make check folder file
    cfcs --src="/home/roman/Изображения" --ext="*.png" > my_images.cs
### Checking files for changes
    cfcs --check_file="my_images.cs"
## Work example
my_test.cs file content:
```
{SETTINGS}
check_file	None
src	/mnt/anydata/tmp
alg	md5
ext	['*.img']
start_time	2022-12-17 14:05:42.637208

{FILES_AND_CONTROL_SUM}
A981130CF2B7E09F4686DC273CF7187E	test1.img
CD573CFAACE07E7949BC0C46028904FF	test5.img
CD573CFAACE07E7949BC0C46028904FF	test3.img
CD573CFAACE07E7949BC0C46028904FF	test0.img
C698C87FB53058D493492B61F4C74189	test2.img
CD573CFAACE07E7949BC0C46028904FF	test4.img
{INFO AND STATISTICS}
Ended: 2022-12-17 14:05:58.980157	Files: 6;	Bytes processed: 9663676416
Processing speed [MiB/sec]: 563.913
hash_val	DD44D3D71819D7EE6A5622544AE1905E
```

## Checking files for changes
    cfcs --check_file="my_test.cs"

### Result
```
Checking files by their checksums has begun!
The file has been verified. No changes found.: /mnt/anydata/big_archive.tar.gz
Total files checked: 1
Number of modified files: 0
Number of I/O errors: 0
File scan speed [MiB/s]: 82.969
```
## PyPi
https://pypi.org/project/calc-files-control-sum/

## Internationalization
Most of the program messages are translated into five languages: English, Russian, German, Spanish, French.
See: https://github.com/octaprog7/PyInternalization.
ln_jupyter_extra 0.1.27
ln_jupyter_extra
Requires Python: >=3.8

# ln_jupyter_extra

[![Github Actions Status](/workflows/Build/badge.svg)](/actions/workflows/build.yml)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh//main?urlpath=lab)


A JupyterLab extension.

## Requirements

- JupyterLab >= 4.0.0

## Install

To install the extension, execute:

```bash
pip install ln_jupyter_extra
```

## Uninstall

To remove the extension, execute:

```bash
pip uninstall ln_jupyter_extra
```

## Contributing

### Development install

Note: You will need NodeJS to build the extension package.

The `jlpm` command is JupyterLab's pinned version of
[yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
`yarn` or `npm` in lieu of `jlpm` below.

```bash
# Clone the repo to your local environment
# Change directory to the ln_jupyter_extra directory
# Install package in development mode
pip install -e "."
# Link your development version of the extension with JupyterLab
jupyter labextension develop . --overwrite
# Rebuild extension Typescript source after making changes
jlpm build
```

You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.

```bash
# Watch the source directory in one terminal, automatically rebuilding when needed
jlpm watch
# Run JupyterLab in another terminal
jupyter lab
```

With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).

By default, the `jlpm build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:

```bash
jupyter lab build --minimize=False
```

### Development uninstall

```bash
pip uninstall ln_jupyter_extra
```

In development mode, you will also need to remove the symlink created by `jupyter labextension develop`
command. To find its location, you can run `jupyter labextension list` to figure out where the `labextensions`
folder is located. Then you can remove the symlink named `ln-jupyter-extra` within that folder.

### Testing the extension

#### Frontend tests

This extension is using [Jest](https://jestjs.io/) for JavaScript code testing.

To execute them, execute:

```sh
jlpm
jlpm test
```

#### Integration tests

This extension uses [Playwright](https://playwright.dev/docs/intro) for the integration tests (aka user level tests).
More precisely, the JupyterLab helper [Galata](https://github.com/jupyterlab/jupyterlab/tree/master/galata) is used to handle testing the extension in JupyterLab.

More information are provided within the [ui-tests](./ui-tests/README.md) README.

### Packaging the extension

See [RELEASE](RELEASE.md)

pip install twine
twine upload dist/*
PyBerries 0.2.26
Processing of Bacmman measurement tables
Requires Python: >=3.9

# PyBerries

PyBerries is a Python package that can be used to import, manipulate and plot data from Bacmman measurement tables.

It relies mainly on Pandas for data handling and Seaborn/Matplotlib for plotting.


## Installation

### Optional: install Jupyter-lab (to run Jupyter Notebooks)

#### Anaconda (recommended)

  Anaconda will install both Python and Jupyter-lab (used to run Python notebooks) easily. Note however that it requires ~5 Gb free disk space.
  For a lighter installation procedure, see the next section "Command line install".

  - Download Anaconda from the [official website](https://www.anaconda.com/)
  - Run the installer (leave all options as default)
  - Start "Anaconda Navigator"
  - In Anaconda, launch the "Jupyter Lab" module (you might need to click on "Install" first)

#### Command line install

  - Open a terminal (macOS/Linux) or Powershell (Windows)
  - Install Python
      - Enter the command `python --version`
      - If an error or a version < 3.9 is shown, download and install Python from the [official website](https://www.python.org/downloads/)
  - After installing, restart your terminal/powershell; the `python --version` command should display a version number > 3.9
  - Install Jupyter Lab
      - In a terminal/powershell, run the command `python -m pip install jupyterlab`
      - After the installation completes, Jupyter Lab can be started using the command `jupyter-lab`

### Installing the package

To install the package, use the following command in a terminal:

`python -m pip install PyBerries`

You can also install a specific version number (useful e.g. to make sure you code won't be broken by a future update):

`python -m pip install PyBerries==0.2.8`

In a jupyter notebook, use the command:

`%pip install PyBerries`, or `%pip install PyBerries==0.2.8` for a specific version.


## Getting started
Try downloading and running the [tutorial notebook](https://gitlab.com/MEKlab/pyberries/-/raw/main/Tutorial/Tutorial.ipynb?inline=false) to get acquainted with data import and plotting in PyBerries.

For further details, see the [main functionalities](https://gitlab.com/MEKlab/pyberries/-/blob/main/doc/PyBerries_main_functionalities.md) documentation, as well as the [DatasetPool](https://gitlab.com/MEKlab/pyberries/-/blob/main/doc/DatasetPool/DatasetPool.md) documentation.

For more info and examples on plots, see the [plot_preset documentation](https://gitlab.com/MEKlab/pyberries/-/blob/main/doc/DatasetPool/DatasetPool.plot_preset.md) and the [Seaborn documentation](https://seaborn.pydata.org/index.html)

## Contact
For questions and feedback related to this package please send an email to [daniel.thedie@ed.ac.uk](mailto:daniel.thedie@ed.ac.uk)
bing-search-xiaomei 1.1.1
a bing search tool for mt users
Requires Python: >=3.10

# bing_search_xiaomei MCP server

a bing search tool for mt users

## 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": {
    "bing_search_xiaomei": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/shelmin/PycharmProjects/xiaomei-mcp-server/bing_search_xiaomei",
        "run",
        "bing_search_xiaomei"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "bing_search_xiaomei": {
      "command": "uvx",
      "args": [
        "bing_search_xiaomei"
      ]
    }
  }
  ```
</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 /Users/shelmin/PycharmProjects/xiaomei-mcp-server/bing_search_xiaomei run bing-search-xiaomei
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
locobuzz-python-orm 1.1.5
Python database orm functions for Locobuzz,  common code that is required in all projects
Requires Python: <=3.12,>=3.8
Keywords: locobuzz, python, database

# Locobuzz Python ORM
```markdown
# Database Connection Manager

A Python package for managing database connections in both synchronous and asynchronous contexts using SQLAlchemy. The package provides two main classes: `SyncDatabase` for synchronous operations and `AsyncDatabase` for asynchronous operations with PostgreSQL.

## Features

- Singleton pattern to ensure a single instance of the database connection.
- Support for multiple databases with connection pooling.
- Asynchronous support for improved performance in `AsyncDatabase`.
- Easy switching between different databases.
- Metadata initialization for table management.

## Installation

To install the package, you can use pip:

```bash
pip install locobuzz_python_orm  # Replace with the actual package name
```

## Usage

### Synchronous Database Management

To use the `SyncDatabase`, follow these steps:

```python
from database_helper.database.sync_db import SyncDatabase

# Initialize the SyncDatabase
sync_db = SyncDatabase(connection_string='postgresql://user:password@localhost/dbname')

# Use the SyncDatabase context manager
with sync_db:
    # Execute a query
    results = sync_db.execute_query("SELECT * FROM your_table;")
    print(results)
```

### Asynchronous Database Management

For the `AsyncDatabase`, you'll use `async` and `await` keywords:

```python
import asyncio
from database_helper.database.async_db import AsyncDatabase

async def main():
    # Initialize the AsyncDatabase
    async_db = AsyncDatabase(connection_string='postgresql://user:password@localhost/dbname')

    async with async_db:
        # Execute a query asynchronously
        results = await async_db.execute_query("SELECT * FROM your_table;")
        print(results)

# Run the async main function
asyncio.run(main())
```

### Switching Databases

Both classes support switching databases on the fly:

```python
# For SyncDatabase
sync_db.switch_database('new_dbname')

# For AsyncDatabase
await async_db.switch_database('new_dbname')
```

### Initializing Tables

You can initialize tables metadata using:

```python
# For SyncDatabase
sync_db.initialize_tables(['your_table1', 'your_table2'])

# For AsyncDatabase
await async_db.initialize_tables(['your_table1', 'your_table2'])
```

## Error Handling

Both classes include basic error handling. If an error occurs during database operations, exceptions will be raised. You can implement additional logging as needed.

## Dependencies

- SQLAlchemy
- Database connectors such as `pyodbc`, `pymysql`, `psycopg2`, `aioodbc`, `aiomysql`, `asyncpg` 

## Author

Atharva Udavant

[GitHub Profile](https://github.com/Atharva17062002)  
[Email](mailto:17.atharva@gmail.com)
marketing-compliance-common 0.1.1
A shared Python library holding types and common functionality
Requires Python: >=3.6

# Shared Python Library

A Python library for reusable components and utilities to streamline development across multiple projects. This library is designed to be shared across various services, with built-in support for deployment and integration.

---

## Features

- 🚀 **Reusable Utilities**: Pre-built, reusable functions for common tasks.
- 🐍 **Python 3.12 Ready**: Leverages the latest Python features.
- 🧪 **Tested**: Comprehensive unit tests ensure code reliability.
- 🔧 **CI/CD Integration**: Built with GCP Cloud Build and deployable to AWS ECR.
- 📦 **Packaging Support**: Ready to publish to private or public PyPI.

---

## Getting Started

### Prerequisites

- Python 3.12 or later
- `poetry` (preferred) or `pip`
- Docker (optional, for containerized workflows)

### Installation

#### Install in service
```bash
docker run -it <aws_account_id>.dkr.ecr.<region>.amazonaws.com/<repository_name>:<tag> bash