semvec/pypi-packages huggingface dataset:
python-bvk 0.4.1
Python library for tracking water consumption from BVK (Brnenske vodarny a kanalizace, bvk.cz)
Requires Python: >=3.9
Keywords: scrapy, water consumption, bvk

# python-bvk

Water conspmution scraper for BVK (Brnenské vodárny a kanalizace, bvk.cz)

Note that you need to have the "smart" water-gauge installed. If you don't know
what that is you probably don't have one. If you don't have one you have to ask
them (BVK) to install it for you and you may have to wait a potentially long
time - they are rolling them out gradually.


## Install

```
pip install python-bvk
```

## Usage

To create the client object you need to provide your BVK username/password
(the one you use on the customer portal https://zis.bvk.cz/).

```
from bvk import Bvk
from dateutil import parser

# Create client
bvk = Bvk('username', 'password')
```

Use `getwaterConsumption()` method to get the water consumption data. It accepts
a `date_from` and optionally a `date_to`, both of which have to be a
[datetime.date](https://docs.python.org/3/library/datetime.html#datetime.date)
object. If `date_to` is not specified the method returns data to today.

Examples:

```
# Get water consumption data from the specified date to now
date_from = parser.parse('2020-08-01').date()
deferred_data = bvk.getWaterConsumption(date_from);

# Get water consumption data for a date interval
date_from = parser.parse('2020-08-01').date()
date_to = parser.parse('2020-08-11').date()
deferred_data = bvk.getWaterConsumption(date_from, date_to);

# Get water consumption data for a specific date (just 1 day)
date = parser.parse('2020-08-01').date()
deferred_data = bvk.getWaterConsumption(date, date);
```

You may call `getWaterConsumption` multiple times with different parameters. It
returns a
[twisted.internet.defer.Deferred](https://twistedmatrix.com/documents/current/core/howto/defer.html)
object that can be used to retrieve the price data in the future using a
callback you need to provide.

```
def process_consumption(consumption)
  print(consumption)

deferred_data.addCallback(process_consumption)
```

If you have multiple `Deferred`s from multiple calls to `getWaterConsumption`
you can use `Bvk.join()` to get a `Deferred` that will be resolved after all
crawlers are finished.

The last callback should stop the reactor so it's shut down cleanly. Reactor
should be stopped after all crawlers are done so the `join()` method comes in
handy. Note that the reactor cannot be restarted so make sure this is the last
thing you do:

```
from twisted.internet import reactor

d = bvk.join()
d.addBoth(lambda _: reactor.stop())
```

The last thing you need to do is run the reactor. The script will block until
the crawling is finished and all configured callbacks executed.

```
reactor.run(installSignalHandlers=False)
```

Keep in mind the library is using [Scrapy](https://scrapy.org) internally which means it is
scraping the BVK customer portal to get the data. If BVK comes to think you are
abusing the website they may block your IP address and/or account.


# License

See [LICENSE](./LICENSE).
tamil-lemmatizer 0.0.2
Tamil word lemmatizer. Converts inflected Tamil words into base lemma.
Requires Python: >=3.0

# Tamil Lemmatizer

**Tamil Lemmatizer** is a character-level lemmatization library for Tamil text.  
It normalizes inflected Tamil word forms and maps them to their base lemma using a deep learning model (PyTorch).

---

## ✨ Features

- ✅ Lemmatizes Tamil words to their base form
- ✅ Handles unseen words using a character-level sequence model
- ✅ Simple Python API
- ✅ Supports batch inference
- ✅ Open-source and extensible

---

## 📦 Installation

```bash
pip install tamil-lemmatizer
````

---

## 🚀 Quick Start

```python
from tamil_lemmatizer import TamilLemmatizer

lemmatizer = TamilLemmatizer()

word = "சென்றார்கள்"
lemma = lemmatizer.lemmatize(word)

print(lemma)   # Output: செல்
```

### Batch input

```python
words = ["பாடுகிறது", "வந்தார்கள்", "சென்றேன்"]
print(lemmatizer.lemmatize_batch(words))
```

---

## 📚 Description

Tamil is morphologically rich. A single lemma can have hundreds of inflected variations.
This library uses:

* A character-level encoder-decoder architecture
* Trained using PyTorch on a curated Tamil lemma dataset
* Supports lemmatization for verbs and nouns

---

## 🛠️ Model Architecture

* Encoder: BiLSTM or Transformer (depending on version)
* Decoder: Attention-based sequence generator
* Loss: Cross entropy over Tamil character vocabulary

---

 

---

## 🔧 CLI Usage

```bash
tamil-lemmatizer "வந்தார்கள்"
```
 
---

## 📄 License

This project is released under the **MIT License**.

---

## 🤝 Contributing

Pull requests are welcome.
If contributing major changes, open an issue first to discuss what you want to change.

---

## ✉️ Contact

Maintainer: **Hemanth Kumar**
GitHub: [Hemanth Thunder](https://github.com/Hemanthkumar2112) 

---
poetry-lock-package 0.5.3
Poetry lock package generator
Requires Python: >=3.9.0

Poetry lock package generator
=========================

Simple script that will take a `pyproject.toml` and a `poetry.lock` and generate a new poetry project where all the lock versions are pinned dependencies.

In theory this will allow you to transport your lock file to any system that is able to install python packages and dependencies.

After installation, the command `poetry-lock-package` should be run next to your `pyproject.toml` and `poetry.lock` files and will generate a subdirectory with a `pyproject.toml` requiring all the dependencies of the lock file.

Simply enter the subdirectory, build and publish the package and you have a '-lock' package that depends on all the exact versions from your lock file.


Example workflow
---------------
The example workflow below will add `poetry-lock-package` as a dev dependency, allowing `poetry run` to find the command.

First create a new poetry project

    poetry new example-package
    cd example-package

Add some dependencies, and see what we have build so far

    poetry add loguru click
    poetry install
    poetry build
    ls dist

Add `poetry-lock-package` to allow for `poetry run` to find the entry point script:

    poetry add --dev poetry-lock-package

Finally build the lock package and see what we have gotten

    poetry run poetry-lock-package --build
    ls -al dist

You will now have two wheel files in your dist folder: one with the project code, one name `example-package-lock` which depends on the exact version of all the packages specified in your `poetry.lock` file.

Using `--no-root`
-----------------
Default behavior is to have the lock package depend on the original package the lock was created for. If you have a private repository, this will allow you to publish both packages to the private repository and only require you to point at one package to install everything.

If you want to be able to install the dependencies, but not the package itself, you can use the `--no-root` command line argument to stop `poetry-lock-package` from adding your root project to the lock package dependencies.

Using `--ignore`
----------------
If you want to allow pip to have freedom in selecting a package, or you expect to deploy in an environment that already has the right version installed, you can opt to use `--ignore` to remove that dependency from the lock package pinned dependencies.

Because `poetry-lock-package` is aware of the dependency graph, it will not only skip locking the dependency but also transitive dependencies.

Contributing code
-----------------

- Open an issue
- Create an associated PR
- Make sure to black format the proposed change

    poetry run pre-commit install

- Add tests where possible

License
-------
GPLv3, use at your own risk.
PySingletonMeta 0.1.0.3
Singleton Metaclass for comfy imports
Requires Python: >=3.8

# PySingletonMeta

A lightweight singleton metaclass for clean and comfy imports.

---
## Installation

```bash
pip install PySingletonMeta
```

---
## Example

```python
from pysingletonmeta import SingletonMeta

class StreamingService(metaclass=SingletonMeta):
    pass

a = StreamingService()
b = StreamingService()

assert a is b  # True
```

---

That’s all you need.
mcp-learning 0.2.0
Exploring different features of MCP servers and clients
Requires Python: <3.14,>=3.13
Keywords: mcp, mcp-server, mcp-client

# Learning Model Context Protocol

This project explores the features and usage of Model Context Protocol (MCP) servers and clients, providing a hands-on learning environment for experimenting with MCP-based tools and workflows.

## Documentation

- [Installation Guide](https://github.com/yarnabrina/learn-model-context-protocol/blob/main/docs/installation.md) — How to set up your environment and install dependencies.
- [Examples & Usage](https://github.com/yarnabrina/learn-model-context-protocol/blob/main/docs/examples.md) — Step-by-step usage and sample sessions.
- [MCP Server Configuration](https://github.com/yarnabrina/learn-model-context-protocol/blob/main/docs/configurations/mcp-server.md)
- [MCP Client Configuration](https://github.com/yarnabrina/learn-model-context-protocol/blob/main/docs/configurations/mcp-client.md)

## Contributing

Please see [CONTRIBUTING.md](https://github.com/yarnabrina/learn-model-context-protocol/blob/main/CONTRIBUTING.md) for development and contribution guidelines.

## Links

- PyPI Package: [mcp-learning](https://pypi.org/project/mcp-learning/)
- MCP Registry: [mcp-learning](https://registry.modelcontextprotocol.io/servers/io.github.yarnabrina/mcp-learning)

## License

This project is licensed under the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later).

Copyright (C) 2025 Anirban Ray

See the [LICENSE](https://github.com/yarnabrina/learn-model-context-protocol/blob/main/LICENSE) file for details.

<!-- mcp-name: io.github.yarnabrina/mcp-learning -->
stockstats-polars 0.1.0
Namespace extension of Polars with stock statistics/indicator calculation helper
Requires Python: >=3.13

# StockStats-Polars

Namespace extension of Polars with stock statistics/indicator calculation helper

Polars implementation of the **stockstats** idea: compute technical indicators inline on your price (ohlcv) DataFrame with simple access.


# Inspiration

This project is inspired by [**stockstats**](https://github.com/jealous/stockstats).
A Pandas dataframe implementation of stock indicators.

A big thanks and credit to Cedric Zhuang for his work on that library. 
Whose implementations I've based this library upon.