semvec/pypi-packages huggingface dataset:
mm-geo-coder 0.2.1
A Goe_coder to locate the coordinates of addresses from Myanmar
Requires Python: >=3.9

# Title
**Myanmar Address Geo Coder**

## Description

This project addresses the lack of a standardized module for Myanmar addresses and aims to make it easier for developers to retrieve the geographic coordinates of locations across Myanmar. It first searches the MIMU database to find the most precise match at the village or ward level. If a match is not found, it progressively falls back to the township, district, or region levels to provide the nearest available coordinates. If the address cannot be found in the MIMU database, the system then uses Nominatim (based on OpenStreetMap) as a fallback to retrieve the geolocation data.

### Tasks

1. **Searching the Mimu database**: Parse the given address into components (state, district, township, ward, village) and query the MIMU database for a match.
2. **Fallback to nearest available level**: If still not found, return the latitude and longitude of the nearest available administrative level (township, district, or region).
3. **Fallback to Nominatim**: If no match is found in MIMU, attempt to search using Nominatim.
4. **Return geolocation data**: Provide the best available latitude and longitude based on the search hierarchy.

---

### Installation

Install from [PyPI](https://pypi.org/project/mm-geo-coder/):

```
pip install mm_geo_coder
```
---

### Usage
```
from mm_geo_coder import MMGeoCoder

geo_coder = MMGeoCoder(address)
location = geo_coder.get_geolocation()
print(location)

```
---
## Credits and Licensing

- **Project Lead:** Myo Thida
- **Institution/Affiliation:** MMDT
- **Data Source:** Myanmar Information Management Unit (MIMU), veresion 9.6 resleased in Feb 2025

This project and its outputs are released under the **MIT License**.  
You are free to use, modify, and distribute the code and dataset with proper attribution.

> © 2025 Myo Thida. All rights reserved.  
> If you use this project in your work, please cite or link back to this repository and the parent project:  
> _"From Words to Coordinates: Mapping Myanmar's Unstructured Addresses to Coordinates."_
sbcli-sfam1977 0.0.1
CLI for managing SimplyBlock cluster


# SBCLI (SimplyBlock CLI)

Simplyblock provides a feature-rich CLI (command line interface) to deploy SimplyBlock Cluster and to manage the SimplyBlock Control plane

## Install

The CLI can be installed using pypi package [sbctl](https://pypi.org/project/sbctl/)

```
pip install --upgrade sbctl
```

# Components

## Simply Block Core
Contains core logic and controllers for the simplyblock cluster

## Simply Block CLI
The list of all the available CLI options can be here [CLI docs](./simplyblock_cli/README.md)

## SimplyBlock Web API

Web app that provides API to manage the cluster. More about this in [README.md](./simplyblock_web/README.md)


### local development

FoundationDB requires a client library (libfdb_c.dylib) for the Python bindings to interact with the database.
Depending on the OS architecture, please install the appropriate version from the official github repo

```
wget https://github.com/apple/foundationdb/releases/download/7.3.3/FoundationDB-7.3.3_arm64.pkg
```
setup the code on a management node and the webApp code can be developed by building the `docker-compose-dev.yml` file.

```
sudo docker compose -f docker-compose-dev.yml up --build -d
```
AeroMesh 0.1.2
A customizable mesher for wind farm simulations and analysis.
Requires Python: >=3.8

# AeroMesh

**AeroMesh** is a wind farm mesher that makes generating finite elements meshes easy. It can accept farm specifications
from either a properly formatted YAML file or from an external API call made by another process. It currently supports refinement specifications
at the domain, farm, and turbine level in both two and three dimensions.
qocogen 0.1.9
QOCOGEN: Custom Code Generator for the QOCO solver
Requires Python: >=3.8

# QOCOGEN
<p align="center">
  <img src="https://github.com/user-attachments/assets/7bd44fa7-d198-4739-bb79-a5c15e04a8de" alt="drawing" width="500"/>
</p>

<p align="center">
  <a href=https://github.com/qoco-org/qocogen/actions/workflows/unit_tests.yml/badge.svg"><img src="https://github.com/qoco-org/qocogen/actions/workflows/unit_tests.yml/badge.svg"/></a>
  <a href="https://img.shields.io/pypi/dm/qocogen.svg?label=Pypi%20downloads"><img src="https://img.shields.io/pypi/dm/qocogen.svg?label=Pypi%20downloads" alt="PyPI Downloads" /></a>
  <a href="https://arxiv.org/abs/2503.12658"><img src="http://img.shields.io/badge/arXiv-2503.12658-B31B1B.svg"/></a>
  <a href="https://qoco-org.github.io/qoco/codegen/index.html"><img src="https://img.shields.io/badge/docs-online-brightgreen?logo=read-the-docs&style=flat" alt="Documentation" /></a>
  <a href="https://opensource.org/licenses/BSD-3-Clause"><img src="https://img.shields.io/badge/License-BSD_3--Clause-green.svg" alt="License" /></a>
</p>

QOCOGEN is a code generator which takes in an second-order cone program problem family and generates a customized C solver (called qoco_custom) for the specified problem family which implements the same algorithm as QOCO. This customized solver is library-free, only uses static memory allocation, and can be a few times faster than QOCO.

## Installation and Usage

You can install `qocogen` by running `pip install qocogen`.

For instructions on using QOCOGEN, refer to the [documentation](https://qoco-org.github.io/qoco/codegen/index.html).

## Tests
To run tests, first install cvxpy and pytest
```bash
pip install cvxpy pytest
```

and execute:

```bash
pytest
```

## Bug reports

File any issues or bug reports using the [issue tracker](https://github.com/qoco-org/qocogen/issues).

## Citing
```
@misc{chari2025qoco,
  title         = {QOCO: A Quadratic Objective Conic Optimizer with Custom Solver Generation},
  author        = {Chari, Govind M and A{\c{c}}{\i}kme{\c{s}}e, Beh{\c{c}}et},
  year          = {2025},
  eprint        = {2503.12658},
  archiveprefix = {arXiv},
  primaryclass  = {math.OC},
  url           = {https://arxiv.org/abs/2503.12658}
}
```

## License
QOCOGEN is licensed under the BSD-3-Clause license.
acl-cpp-python 0.6.2
Python bindings for the AtCoder Library
Requires Python: >=3.9
Keywords: AtCoder, AtCoder Library, ACL

# acl-cpp-python

[![GitHub: acl-cpp-python](https://img.shields.io/badge/GitHub-acl--cpp--python-darkmagenta?logo=GitHub&logoColor=white)](https://github.com/tatyam-prime/acl-cpp-python)
[![PyPI: acl-cpp-python](https://img.shields.io/badge/PyPI-acl--cpp--python-006dad?logo=PyPI&logoColor=white)](https://pypi.org/project/acl-cpp-python/)
[![AC Library: v1.6](https://img.shields.io/badge/AC%20Library-v1.6-seagreen)](https://github.com/atcoder/ac-library) [![License: CC0 1.0](https://img.shields.io/badge/License-CC0%201.0-darkgoldenrod)](https://creativecommons.org/publicdomain/zero/1.0/)

Documentation: [日本語](https://tatyam-prime.github.io/acl-cpp-python/ja/) | [English](https://tatyam-prime.github.io/acl-cpp-python/en/)

[acl-cpp-python](https://github.com/tatyam-prime/acl-cpp-python/) is a package that binds the [AtCoder Library (ACL)](https://github.com/atcoder/ac-library) implemented in C++ to Python.
Internally, it is implemented in C++, so you can use fast convolutions, flows, string algorithms, etc. from Python.
py-module-injector 0.1.3
Uma biblioteca de modularização em python

﻿# python-module
Uma biblioteca de modularização em Python que fornece funcionalidades para injeção de dependências e registro de módulos, facilitando a criação de sistemas modulares e extensíveis.

## Instalação
Para instalar a biblioteca, execute o seguinte comando no terminal:
```
pip install .
```

## Uso
Injeção de Dependências
A biblioteca oferece suporte à injeção de dependências, permitindo que você registre e injete automaticamente as dependências necessárias em classes e métodos.

Exemplo de uso da injeção de dependências em uma classe:

```
from python_module import Inject

@Inject
class ServiceBase:
    def __init__(self, provider: Provider):
        self.provider = provider

    def get_log(self):
        return self.provider.get_log()
```

## Registro de Módulos
Com o decorador ``@Module``, você pode registrar módulos e suas dependências no injetor de dependências. Esse registro permite que você defina quais implementações ou fábricas serão utilizadas em diferentes partes do seu aplicativo.

Exemplo de uso do decorador Module:

```
from python_module import Module
from python_module.typing import RegisterModuleType

@Module(
    module_name="ExampleModule",
    instances=[
        RegisterModuleType(
            implementation=Provider,  # Deve ser uma referência à classe, não uma string
            factory=lambda: Provider(log="Provider Injetado")
        )
    ]
)
class ExampleModule:
    def run(self):
        service = Service()
        return service.process()

if __name__ == '__main__':
    example_module = ExampleModule()
    print(example_module.run())
```
## Testes
Para rodar os testes da biblioteca, execute o seguinte comando:

```
python -m unittest discover -s tests
```
Isso irá descobrir e rodar todos os testes na pasta tests.

## Contribuição
Sinta-se à vontade para contribuir com melhorias, correções de bugs ou novas funcionalidades! Para isso, basta fazer um fork do repositório, criar uma nova branch e enviar um pull request