semvec/pypi-packages huggingface dataset:
eam-db-helper 0.0.6
A package to interact with ms graph /users functionality
Requires Python: >=3.8

# This package is used as a layer above MS cosmos db python sdk to interact with data in ms cosmos db sql api.


DatabaseHelper:


DatabaseHelper.get_results():

This method is ussed to get the results from the cosmos db. It takes the query and the parameters of the query as input and returns the results as a list. 



DatabaseHelper.get_result():

This method is used to get the result from the cosmos db. It takes the query and the parameters of the query as input and returns the result as a dictionary.




DatabaseHelper.get_column():

This method is used to get the column from the cosmos db. It takes the query and the parameters of the query as input and returns the column as a list.




DatabaseHelper.delete_item():

This method is used to delete the item from the cosmos db. It takes the item id, as well as the partition key (type) as input and returns None.




DatabaseHelper.upsert():

This method is used to upsert the item in the cosmos db. It takes the item as input and returns None.
polors 0.2.4
Add your description here
Requires Python: >=3.11

## polORs - Operation Research with polars


This package is heavily inspired by [gurobipy-pandas](https://github.com/Gurobi/gurobipy-pandas) but uses polars as dataframe backend.


### Basic example
```python

import polors.gurobi as pg
import gurobipy as gp

model = gp.Model()

df = pl.DataFrame(
    {
        "i": [0, 0, 1, 2, 2],
        "j": [1, 2, 0, 0, 1],
        "u": [0.3, 1.2, 0.7, 0.9, 1.2],
        "c": [1.3, 1.7, 1.4, 1.1, 0.9],
        "obj": [2.5, 2.7, 1.2, 1.7, 3.9],
    }
)

df = (
    df
    .pipe(pg.add_vars, model, name="x", ub="u", obj = "obj", indices = ["i", "j"], vtype = gp.GRB.CONTINUOUS)
)
# shape: (5, 6)
# ┌─────┬─────┬─────┬─────┬─────┬─────────────────────┐
# │ i   ┆ j   ┆ u   ┆ c   ┆ obj ┆ x                   │
# │ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ ---                 │
# │ i64 ┆ i64 ┆ f64 ┆ f64 ┆ f64 ┆ object              │
# ╞═════╪═════╪═════╪═════╪═════╪═════════════════════╡
# │ 0   ┆ 1   ┆ 0.3 ┆ 1.3 ┆ 2.5 ┆ <gurobi.Var x[0,1]> │
# │ 0   ┆ 2   ┆ 1.2 ┆ 1.7 ┆ 2.7 ┆ <gurobi.Var x[0,2]> │
# │ 1   ┆ 0   ┆ 0.7 ┆ 1.4 ┆ 1.2 ┆ <gurobi.Var x[1,0]> │
# │ 2   ┆ 0   ┆ 0.9 ┆ 1.1 ┆ 1.7 ┆ <gurobi.Var x[2,0]> │
# │ 2   ┆ 1   ┆ 1.2 ┆ 0.9 ┆ 3.9 ┆ <gurobi.Var x[2,1]> │
# └─────┴─────┴─────┴─────┴─────┴─────────────────────┘

(
    df
    .pipe(pg.apply_eval, "y = 2 * x - c")
    .group_by("i").agg(pg.quicksum("y"), pl.col("c").min())
    .pipe(pg.add_constrs, model, "y <= c", name="constr")
)
# shape: (3, 4)
# ┌─────┬────────────────────────────────┬─────┬────────────────────────┐
# │ i   ┆ y                              ┆ c   ┆ constr                 │
# │ --- ┆ ---                            ┆ --- ┆ ---                    │
# │ i64 ┆ object                         ┆ f64 ┆ object                 │
# ╞═════╪════════════════════════════════╪═════╪════════════════════════╡
# │ 1   ┆ -1.4 + 2.0 x[1,0]              ┆ 1.4 ┆ <gurobi.Constr constr> │
# │ 0   ┆ -3.0 + 2.0 x[0,1] + 2.0 x[0,2] ┆ 1.3 ┆ <gurobi.Constr constr> │
# │ 2   ┆ -2.0 + 2.0 x[2,0] + 2.0 x[2,1] ┆ 0.9 ┆ <gurobi.Constr constr> │
# └─────┴────────────────────────────────┴─────┴────────────────────────┘

model.optimize()
```
linklinux-init 1.2.0
A tool to configure initial development environment on Linux

LinkLinux Init
==============

LinkLinux Init is a tool designed to quickly set up an initial development environment on Linux. It provides automated setup of common tools like vim, zsh, and other essential software for developers.

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

To install LinkLinux Init, use the following command:

.. code:: bash

   pip install linklinux-init

Usage
-----

To run the tool:

.. code:: bash

   linklinux-init
flarejax 0.4.11
Flexible Neural Networks in JAX
Requires Python: >=3.10

# FlareJax
FlareJax is a Python library for building neural networks and optimizers in Jax. It is designed to minimize the time between a new research idea and its implementation.

## Features
- Mutable modules for quick and dirty modifications via `Module`
- Serialization of modules via `@saveable`, `save`, and `load`
- Systematically modifying modules by using `flatten` and `unflatten`
- Safely handling shared/cyclical references and static arguments through `filter_jit`
- Commonly used NN layers and optimizers are included
- As a small codebase, it is relatively easy to understand and extend

## Quick Example
Define new Modules by subclassing `Module`. All methods are callable PyTrees.

```python
@flr.saveable("Example:Linear")  # optional, make saveable
class Linear(flr.Module):
    def __init__(self, key: PRNGKeyArray, dim: int):
        self.dim = dim
        self.w = None

    def __call__(self, x):
        # lazy initialization dependent on the input shape
        if self.w is None:
            self.w = jrn.normal(key, (x.shape[-1], self.dim))

        return x @ self.w

layer = Linear(jrn.PRNGKey(0), 3)
x = jnp.zeros((1, 4))

# the model is initialized after the first call
y = layer(x)
assert layer.w.shape == (4, 3)
```

For optimization, define a loss function, which takes the module as the first argument.

```python
def loss_fn(module, x, y):
    return jnp.mean((module(x) - y) ** 2)

opt = flr.opt.Adam(3e-4)

# automatically just-in-time compiled
opt, model, loss = flr.train(opt, model, loss_fn, x, y)
```

Models can be saved and loaded.

```python
flr.save(layer, "model.npz")

# load the model
layer = flr.load("model.npz")
assert isinstance(layer, Linear)
```

## Installation
FlareJax can be installed via pip. It requires Python 3.10 or higher and Jax 0.4.33 or higher.

```bash
pip install flarejax
```

## See Also
- [Jax Docs](https://jax.readthedocs.io/en/latest/): Jax is a library for numerical computing that is designed to be composable and fast.
- [Equinox library](https://github.com/patrick-kidger/equinox): FlareJax is heavily inspired by this awesome library.
- [torch.nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html): Many of the principles of mutability are inspired by PyTorch's `torch.nn.Module`.
- [NNX Docs](https://flax.readthedocs.io/en/v0.8.3/experimental/nnx/index.html/): NNX is a library for neural networks in flax that also supports mutability.
- Always feel free to reach out to me via [email](mailto:paul.wollenhaupt@gmail.com).
gensor 0.2.5
Library for handling groundwater sensor data.
Requires Python: >=3.11

# gensor

[![Release](https://img.shields.io/github/v/release/zawadzkim/gensor)](https://img.shields.io/github/v/release/zawadzkim/gensor)
[![Build status](https://img.shields.io/github/actions/workflow/status/zawadzkim/gensor/main.yml?branch=main)](https://github.com/zawadzkim/gensor/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/zawadzkim/gensor/branch/main/graph/badge.svg)](https://codecov.io/gh/zawadzkim/gensor)
[![Commit activity](https://img.shields.io/github/commit-activity/m/zawadzkim/gensor)](https://img.shields.io/github/commit-activity/m/zawadzkim/gensor)
[![License](https://img.shields.io/github/license/zawadzkim/gensor)](https://img.shields.io/github/license/zawadzkim/gensor)

Library for handling groundwater sensor data.

- **Github repository**: <https://github.com/zawadzkim/gensor/>
- **Documentation** <https://zawadzkim.github.io/gensor/>

## Getting started with your project

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:zawadzkim/gensor.git
git push -u origin main
```

Finally, install the environment and the pre-commit hooks with

```bash
make install
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPi or Artifactory, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/codecov/).

## Releasing a new version

- Create an API Token on [Pypi](https://pypi.org/).
- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/zawadzkim/gensor/settings/secrets/actions/new).
- Create a [new release](https://github.com/zawadzkim/gensor/releases/new) on Github.
- Create a new tag in the form `*.*.*`.
- For more details, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/cicd/#how-to-trigger-a-release).

---

Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).