semvec/pypi-packages huggingface dataset:
py-smn 0.1.0
A Python wrapper for the SMN API Argentina
License: MIT
Requires Python: >=3.6
Keywords: smn,weather,forecast,api,argentina,smn-api

# py-smn
A free and open source Python library for retrieving weather data from the National Meteorological Service of Argentina (SMN). 

## Note
This package offers two ways to obtain the requested data, the first is through the [API](https://ws.smn.gob.ar) of SMN and the second is by the public data offered by the official SMN [website](https://www.smn.gob.ar/descarga-de-datos). I recommend you use the second option since it is more accurate and is updated every day.


## Installation
From PyPI
```bash
pip install py-smn
```
From source code clone it
```bash
git clone https://github.com/manucabral/py-smn.git
cd py-smn
python -m pip install -r requirements.txt
```


## Usage
Using static (recommended method)
```py
import asyncio
import smn

async def main():
    async with smn.Client() as client:
        forecast_now = await client.get_static()
        province, lat, lon = await client.get_location()
        nearest_forecast = forecast_now.nearest(lat, lon)
        print(nearest_forecast.weather['temp'])

if __name__ == '__main__':
    asyncio.run(main())
```

Using API
```py
import asyncio
import smn

async def main():
    async with smn.Client() as client:
        forecast_now = await client.get(forecast='now')
        weather_stations = forecast_now.filter(province='Buenos Aires', name='La Plata')
        for weather_station in weather_stations:
            print(weather_station.name, weather_station.weather['temp'])

if __name__ == '__main__':
    asyncio.run(main())
```

## Constributions
All constributions, bug reports or fixes and ideas are welcome.
yandex-geocoder 3.0.1
Simple library for getting address or coordinates via Yandex geocoder
License: MIT
Requires Python: >=3.9,<4.0

# Yandex Geocoder

Get address coordinates via Yandex geocoder

[![test](https://github.com/sivakov512/yandex-geocoder/workflows/test/badge.svg)](https://github.com/sivakov512/yandex-geocoder/actions?query=workflow%3Atest)
[![Coverage Status](https://coveralls.io/repos/github/sivakov512/yandex-geocoder/badge.svg?branch=master)](https://coveralls.io/github/sivakov512/yandex-geocoder?branch=master)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
[![Python versions](https://img.shields.io/pypi/pyversions/yandex-geocoder.svg)](https://pypi.python.org/pypi/yandex-geocoder)
[![PyPi](https://img.shields.io/pypi/v/yandex-geocoder.svg)](https://pypi.python.org/pypi/yandex-geocoder)

## Installation

Install it via `pip` tool:

```shell
pip install yandex-geocoder
```

or Poetry:

```shell
poetry add yandex-geocoder
```

## Usage example

Yandex Geocoder requires an API developer key, you can get it [here](https://developer.tech.yandex.ru/services/) to use this library.

```python
from decimal import Decimal

from yandex_geocoder import Client


client = Client("your-api-key")

coordinates = client.coordinates("Москва Льва Толстого 16")
assert coordinates == (Decimal("37.587093"), Decimal("55.733969"))

address = client.address(Decimal("37.587093"), Decimal("55.733969"))
assert address == "Россия, Москва, улица Льва Толстого, 16"
```

## Development and contribution

First of all you should install [Poetry](https://python-poetry.org).

- install project dependencies

```bash
make install
```

- run linters

```bash
make lint
```

- run tests

```bash
make test
```

- feel free to contribute!
py2opt 1.4.2
How to solve the traveling salesman problem with the 2-opt algorithm
License: MIT

[![license](https://img.shields.io/badge/license-MIT-success)](https://github.com/pdrm83/Py2Opt/blob/master/LICENSE.md)
[![doc](https://img.shields.io/badge/docs-Medium-blue)](https://towardsdatascience.com/how-to-solve-the-traveling-salesman-problem-a-comparative-analysis-39056a916c9f)

# 2-Opt Search Algorithm 
In optimization, 2-opt is a simple local search algorithm with a special swapping mechanism that suits well to solve the 
traveling salesman problem. This algorithm is sensitive to the initial point of search, i.e., its final results get 
changed by different initial points. 2-opt runs very fast such that a tsp with 120 cities can be solved in less than 
5 sec on the intel core i7. To get a more reliable result, you should run the 2-opt with different randomized initial 
points for enough number of times. One more thing, the travelling salesman problem has many applications in real world 
such as logistic planning or DNA sequencing. So, having a fast and simple method to solve the TSP is valuable. For more 
detailed description, you can read this article: [How to Solve the Traveling Salesman Problem — A Comparative Analysis](https://towardsdatascience.com/how-to-solve-the-traveling-salesman-problem-a-comparative-analysis-39056a916c9f)

 
## Install
The module requires the following libraries:

* numpy
* random2

Then, it can be installed using pip:
```python
pip install py2opt
```

## Usage
To use this module, you must have a distance matrix `dist_mat` showing the pair distance among all nodes. Then, the 
first thing to do is create an instance of the `RouteFinder` class. When you call the `solve` method, you will get the 
`best_route` and `best_distance` of this problem. Check out the example below.

```python
from py2opt.routefinder import RouteFinder

cities_names = ['A', 'B', 'C', 'D']
dist_mat = [[0, 29, 15, 35], [29, 0, 57, 42], [15, 57, 0, 61], [35, 42, 61, 0]]
route_finder = RouteFinder(dist_mat, cities_names, iterations=5)
best_distance, best_route = route_finder.solve()

print(best_distance)
114
print(best_route)
['A', 'C', 'B', 'D']
```
The solver finds out the optimum order (re: minimum total distance traveled) in which the nodes must be visited along 
with the total distance traveled. Note that the 2-opt algorithm doesn't guarantee the global optimum similar to other 
heuristic search algorithms. So, the results can vary in each iteration.

And that's pretty much it!
dpmdtools 1.1.2
DPTools: CLI toolkit and python library for working with deepmd-kit.
License: MIT
Requires Python: >=3.6

# DPTools
**D**eep **P**otential **Tools** (DPTools) provides a command-line interface and python library to simplify training and deploying [DeePMD-kit](https://github.com/deepmodeling/deepmd-kit) machine learning potentials (MLPs), also known as ML force fields. The primary goal of DPTools is to condense workflows for training DP MLPs and running atomistic simulations with [LAMMPS](https://www.lammps.org)  on HPC systems into a handful of intuitive CLI commands. It is intended for scientists with knowledge of quantum mechanics-based *ab-initio* simulation methods who are interested in effortlessly transitioning to ML-based approaches to greatly increase computational throughput. It requires no prior experience with DeePMD-kit or LAMMPS software, only familiarity with the popular [Atomic Simulation Environment (ASE)](https://wiki.fysik.dtu.dk/ase/index.html) python package is needed.

## Main Features

* Setup deepmd-kit training sets from VASP output or common ASE formats
* Train ensemble of DP models
* Generate parity plots to assess accuracy of MLP energy and force predictions
* Intelligently sample and select new training configurations from DPMD trajectories
* Easily setup and run different atomistic simulations in LAMMPS:
	* Single point energy calculations
	* Structure geometry optimizations
	* Structure unit cell optimizations
	* Molecular dynamics (NVT and NPT ensembles)
	* Equations of State and bulk moduli calculations
	* Vibratrional/phonon modes using the finite differences approach
	* Other common simulation methods available upon request
* Supports Slurm job submission on HPC systems
* Setup and run simulations on thousands of structures with a single command

## Documentation
For detailed descriptions on setting up and using DPTools, visit the [official documentation](https://dptools.readthedocs.io).

## Quick Install
The current stable version (1.0.1) of DPTools can be installed using `pip` with the following command:

~~~
pip install dpmdtools
~~~

To verify that the installation was completed successfully, run the command:

~~~
dptools --version
~~~

## Support
If you are having issues with DPTools, create an issue [here](https://github.com/tysours/DPTools/issues). For more assistance, new feature requests, or general inquiries, feel free to contact Ty at tsours@ucdavis.edu.