semvec/pypi-packages huggingface dataset:
qsolve 0.3.2
Numerical framework for the simulation and optimization of ultracold atom experiments

# QSolve

QSolve provides numerical methods for the simulation and optimization 
of ultracold atom experiments at zero and finite temperature.

# Requirements

Ubuntu 22.04 or Windows 11\
Python 3.11

# Getting Started

pip install qsolve

# Update

To upgrade the installed qsolve package to its latest version, please use:

pip install --upgrade qsolve
nepali-date-converter 0.0.1
NepaliDateConverter
Keywords: python,tutorial,date_converter,bikram sambat,nepali date converter,nepali datetime,bs to ad converter,ad to bs converter,nepali datetime

# Nepali Date Converter

This is a simple project that converts dates between nepali and english dates.


## Installation
Run the following command to install:

'''python
pip install nepali_date_converter
'''

## Usage

'''python

# Generate "2080-03-18"
from nepali_date_converter import english_to_nepali_converter
english_to_nepali_converter(2023,7,3)

# Generate "2023-07-03"
from nepali_date_converter import nepali_to_english_converter
nepali_to_english_converter(2080, 3, 18)
'''

# Developing nepali_date_converter

To install nepali_date_converter, along with the tools you need to develop and run tests, run the following in your virtualenv:

'''bash
$ pip install -e .[dev]
'''
sqlalchemy-timescaledb 0.4.1
A SQLAlchemy dialect for TimescaleDB

# SQLAlchemy TimescaleDB

[![PyPI version](https://badge.fury.io/py/sqlalchemy-timescaledb.svg)][1]
[![Tests](https://github.com/dorosch/sqlalchemy-timescaledb/actions/workflows/tests.yml/badge.svg)][2]
[![codecov](https://codecov.io/gh/dorosch/sqlalchemy-timescaledb/branch/develop/graph/badge.svg?token=Gzh7KpADjZ)][3]
[![Downloads](https://pepy.tech/badge/sqlalchemy-timescaledb)][4]

This is the TimescaleDB dialect driver for SQLAlchemy. Drivers `psycopg2` and `asyncpg` are supported.

## Install

```bash
$ pip install sqlalchemy-timescaledb
```

## Usage

Adding to table `timescaledb_hypertable` option allows you to configure the [hypertable parameters][5]:

```Python
import datetime
from sqlalchemy import create_engine, MetaData
from sqlalchemy import Table, Column, Integer, String, DateTime

engine = create_engine('timescaledb://user:password@host:port/database')
metadata = MetaData()
metadata.bind = engine

Metric = Table(
    'metric', metadata,
    Column('name', String),
    Column('value', Integer),
    Column('timestamp', DateTime(), default=datetime.datetime.now),
    timescaledb_hypertable={
        'time_column_name': 'timestamp'
    }
)

metadata.create_all(engine)
```

Or using `declarative_base` style:

```Python
import datetime

from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Float, String, DateTime

Base = declarative_base()

class Metric(Base):
    __table_args__ = ({
        'timescaledb_hypertable': {
            'time_column_name': 'timestamp'
        }
    })

    name = Column(String)
    value = Column(Float)
    timestamp = Column(
        DateTime(), default=datetime.datetime.now, primary_key=True
    )
```

## Parameters

* [chunk_time_interval](6)

## Functions

Timescaledb functions implemented:

### [first(value, time)][7]

```Python
func.first(Metric.value, Metric.timestamp)
```

### [last(value, time)][8]

```Python
func.last(Metric.value, Metric.timestamp)
```


[1]: https://badge.fury.io/py/sqlalchemy-timescaledb
[2]: https://github.com/dorosch/sqlalchemy-timescaledb/actions/workflows/tests.yml
[3]: https://codecov.io/gh/dorosch/sqlalchemy-timescaledb
[4]: https://pepy.tech/project/sqlalchemy-timescaledb
[5]: https://docs.timescale.com/api/latest/hypertable/create_hypertable/#optional-arguments
[6]: https://docs.timescale.com/api/latest/hypertable/set_chunk_time_interval/
[7]: https://docs.timescale.com/api/latest/hyperfunctions/first/
[8]: https://docs.timescale.com/api/latest/hyperfunctions/last/
datascrub 1.1.5
A Python package for cleaning and preprocessing data in pandas DataFrames

# DataScrub

DataScrub is a Python package that provides powerful data cleaning and preprocessing capabilities for pandas DataFrames. It offers a collection of functions and utilities to facilitate data cleaning tasks, handling missing values, standardizing data formats, and more. With DataScrub, you can streamline your data preparation process and ensure the quality and consistency of your datasets.

## Features

- Clean text data in pandas DataFrames
- Handle missing values with customizable actions
- Perform scaling normalization on numerical columns
- Split and expand data in specified columns
- Convert columns to datetime format and format them as 'YYYY-MM-DD'
- Translate text columns to English using Google Translate

## Installation

DataScrub can be easily installed using pip. Simply run the following command:

```shell
pip install datascrub
```

Make sure you have Python 3.7 or above installed on your system.

## Usage

To use DataScrub in your Python projects, import the package and create an instance of the `DataClean` class:

```python
from datascrub import DataClean
import pandas as pd

# Create a DataFrame
data = pd.read_csv("data.csv")

# Create an instance of DataClean
cleaner = DataClean(data)

# Call the available methods to clean and preprocess your data
cleaned_data = cleaner.prep(clean='all', missing_values={}, perform_scaling_normalization_bool=False,
                            explode={}, parse_date={}, translate_column_names={})
```

The `DataClean` class takes a pandas DataFrame or a file path as input. You can then use the various methods available in the class to clean and preprocess your data.

Refer to the [documentation](https://github.com/samuelshine/datascrub) for detailed information on available methods and usage examples.

## Contributing

Contributions to DataScrub are welcome! If you encounter any bugs, have suggestions for improvements, or would like to add new features, please open an issue or submit a pull request on the [GitHub repository](https://github.com/samuelshine/datascrub).

## License

This project is licensed under the MIT License. See the [LICENSE](https://github.com/samuelshine/CleanMyData/blob/main/LICENSE.txt) file for more information.
flaxsr 0.0.7
Super Resolution tools with Jax/Flax
Requires Python: >=3.6

# FlaxSR

Super Resolution models with Jax/Flax

<b>Currently, Flax is using CUDA/CuDNN from wheel, but TensorFlow is using local CUDA/CuDNN, which is causing conflicts. We will fix it as soon as possible.<\b>

## HOW TO USE

### Install
```shell
pip install flaxsr
```

### Usage
<b> You can easily load model/losses and train model using custom train_states. </b>

 - Train example
```python
import flaxsr
import jax
import jax.numpy as jnp
import numpy as np
import optax

model_kwargs = {
    'n_filters': 64, 'n_blocks': 8, 'scale': 4
}
model = flaxsr.get("models", "vdsr", **model_kwargs)  # This equals flaxsr.models.VDSR(**model_kwargs)
losses = [
    flaxsr.losses.L1Loss(reduce='sum'),
    flaxsr.get('losses', 'vgg', feats_from=(6, 8, 14,), before_act=False, reduce='mean')
]
loss_weights = (.1, 1.)
loss_wrapper = flaxsr.losses.LossWrapper(losses, loss_weights)
params = model.init(jax.random.PRNGKey(0), jnp.ones((1, 8, 8, 3), dtype=jnp.float32))
tx = optax.adam(1e-3)

state = flaxsr.training.TrainState.create(
    apply_fn=model.apply, params=params, tx=tx, losses=loss_wrapper
)

hr = jnp.ones((1, 32, 32, 3), dtype=jnp.float32)
lr = jnp.ones((1, 8, 8, 3), dtype=jnp.float32)
batch = (lr, hr)

state_new, loss = flaxsr.training.discriminative_train_step(state, batch)

assert state_new.step == 1
np.not_equal(state_new.params['params']['Conv_0']['kernel'], state.params['params']['Conv_0']['kernel'])
```


## flaxsr.get keywords
 - models
   - SRCNN: srcnn
   - FSRCNN: fsrcnn
   - ESPCN: espcn
   - VDSR: vdsr
   - EDSR: edsr
   - MDSR: mdsr
   - SRResNet: srresnet
   - SRGAN: srgan
   - NCNet: ncnet
   
 - losses
   - L1Loss: l1
   - L2Loss: l2
   - CharbonnierLoss: charbonnier
   - VGGLoss: vgg
   - MinmaxDriscriminatorLoss: minmax_discriminator
   - MinmaxGeneratorLoss: minmax_generator
   - LeastSquareDiscriminatorLoss: least_square_discriminator
   - LeastSquareGeneratorLoss: least_square_generator
   - RelativisticDiscriminatorLoss: relativistic_discriminator
   - RelativisticGeneratorLoss: relativistic_generator
   - TotalVariationLoss: tv
   - FrequencyReconstructionLoss: freq_recon
   - EdgeLoss: edge
   
 - layers
   - DropPath: droppath
   - DropPathFast: droppath_fast
   - PixelShuffle: pixelshuffle
   - NearestConv: nearestconv
 
 - train_step
   - discriminative_train_step: discriminative