semvec/pypi-packages huggingface dataset:
timeless 0.2.7
Datetime for people in a hurry.
License: MIT
Requires Python: >=3.8,<4.0
Keywords: datetime,datetime for humans

# Timeless - a datetime toolkit for people in a hurry.

**Timeless** sits on sholders of giants to provide a simple and easy to use datetime
toolkit. Simple date ranges, datetime operations and just one import.

This package is a work in progress and it was created as a study object.

## 🧠 Features

- ✔️ very simple API
- ✔️ minimal code to get things done
- ✔️ easy use with other packages
- ✔️ just one import
- ✔️ few dependencies

## 📦 Installation

```bash
pip install timeless
```

## 📝 Why Timeless?

It provides a simple API, heavily inspired by [Pendulum](https://github.com/sdispater/pendulum).

I love Pendulum, although since last year (maybe 2 years) it doesn't seem to be actively maintained. If you like Pendulum, you will like Timeless. If you want a easy to adopt, integrate and expand package, you will like Timeless.

## 💻 Sample usage

Timeless use two main concepts: `Datetime` and `Period`. A datetime is a point in Time, and a Period is a duration.

Timeless doesn`t differentiate between datetime and date objects.

All datetimes are assumed to be in the UTC+00:00 timezone if any other timezone isn`t specified.

```python
import timeless

start = timeless.datetime(1900, 1, 1, zone="UTC")
end = start.add(years=1)

end.subtract(months=1)

start.set(year=2099, month=2, day=26, hour=5, zone="America/Sao_Paulo")

start.is_past()  # True
start.is_future()  # False
start.set(year=2099).is_future()  # True
```

## 📜 Docs

The docs are under development, but it's (very) early stage is already [available](https://ericmiguel.github.io/timeless/).

## 🏗️ Development

Timeless relies on [Poetry](https://github.com/python-poetry/poetry).

Install the Python dependencies with:

```bash
poetry install
```

## ⚗️ Testing

```bash
poetry run pytest --cov=timeless tests/
```
pycircleci-async 0.1.1
Async Python client for CircleCI API
License: MIT
Requires Python: >=3.7,<4.0

# pycircleci

[![PyPI version](https://badge.fury.io/py/pycircleci-async.svg)](https://badge.fury.io/py/pycircleci-async)
[![Build Status](https://github.com/theY4Kman/pycircleci-async/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/theY4Kman/pycircleci-async/actions/workflows/test.yml?query=branch%3Amaster)

Asynchronous Python client for [CircleCI API](https://circleci.com/docs/2.0/api-intro/).

Ported from [pycircleci](https://github.com/alpinweis/pycircleci), a fork of the discontinued [circleci.py](https://github.com/levlaz/circleci.py) project.

## Features

- Supports [API v1.1](https://circleci.com/docs/api/#api-overview) and [API v2](https://circleci.com/docs/api/v2/)
- Supports both `circleci.com` and self-hosted [Enterprise CircleCI](https://circleci.com/enterprise/)

## Installation

    $ pip install pycircleci-async

## Usage

Create a personal [API token](https://circleci.com/docs/2.0/managing-api-tokens/#creating-a-personal-api-token).

Set up the expected env vars:

    CIRCLE_TOKEN           # CircleCI API access token
    CIRCLE_API_URL         # CircleCI API base url. Defaults to https://circleci.com/api

```python
import asyncio
from pycircleci_async import CircleCIClient


async def main():
    async with CircleCIClient(token='<access-token-uuid>') as circle_client:
        # get current user info
        await circle_client.get_user_info()

        # get list of projects
        results = await circle_client.get_projects()


asyncio.run(main())
```


### Contributing

1. Fork it
2. Install poetry (`pip install poetry`)
3. Install dependencies (`poetry install`)
4. Create your feature branch (`git checkout -b my-new-feature`)
5. Make sure `flake8` and the `pytest` test suite successfully run locally
6. Commit your changes (`git commit -am 'Add some feature'`)
7. Push to the branch (`git push origin my-new-feature`)
8. Create new Pull Request
cheMLearning 0.0.1
Tools for Metabolomics Multivariate Analysis
License: MIT
Keywords: metabolomics

**cheMLearning** library provides of high-level, user-friendly tools to perform common chemometrics analysis in untargeted metabolomics.
Modelling is done using scikit-learn framework, for machine learning; while visualizations are mainly done with Plotly.

Main modules are: 
- unsupervised_modelling 
- supervised_modelling
- utils

## Installation

```python
pip install cheMLearning
```
within a Jupyter Notebook cell

```python
!pip install cheMLearning
```



# Unsupervised modelling

Unsupervised class works around `Principal Component Analysis`, facilitating the visualization of score and loading plots. Moreover, `Hierarchical Clustering Analysis` can be called on the 
principal components and visualize a score plot where the color code is given by the clusters of the HCA.

Visualizations can be obtained without having to manipulate scores or loadings. However, if one would like to access to these outputs, they can be accessed via class modules.

## Import

```python
from cheMLearning.unsupervised_modelling import unsupervised_class
```

# Supervised modelling

Supervised class includes `Partial Least Squares` and `Random Forest` which can be used for either regression or classification tasks. PLS is computed with the NIPALS algorithm.

In the PLS modelling, tools to compute goodness metrics, i.e. R² and Q², VIPs, are provided. In addition to a static functions to ease feature extraction VIP for a 
given VIP threshold.

For RF modelling, it can be computed the distance matrix for a RF-classifier model. It allows tracking where the observations land in the forest.

Analytical tools for classifiers are also provided by facilitating a classification report.

## Import

```python
from cheMLearning.unsupervised_modelling import supervised_class
```

# Utils

Here, tools to create confusion matrices and ROC curves are provided.
In case one is working with MetaboRank (MR) tool, a function to read MR's output is provided.

## Import

```python
from cheMLearning import utils
```

Change Log
==========

0.0.1 (09/11/2022)
------------------
- First Release
dynamic-tensor 0.0.2
Automatically and minimally expanding tensor for __setitem()__ operations based on NumPy.
License: MIT
Requires Python: >=3.6
Keywords: tensor,numpy,array

# dynamic-tensor

_(This package is still developing and not formally tested. Please report any potential issues. Constantly reshaping the tensor could be inefficient and not suitable for high-performance computing)_

A Python package for automatically and minimally expanding tensors for `__setitem()__` operations based on NumPy. You don't need to worry about tensor shape initialization, `reshape()`, or `expand_dims()` anymore as if the tensor has an infinite size. Both basic (integer, slice, `np.newaxis`, ellipsis) and advanced (integer & boolean array) indexing are supported (refer to [Indexing on ndarrays](https://numpy.org/doc/stable/user/basics.indexing.html#)). 

You can also configure a `DynamicTensor` to adapt the tensor type to the new value to avoid `astype()` (enabled by default).

## Usage

Requires Python 3.6+ and NumPy 1.16+.

```bash
pip install dynamic-tensor
# or using conda
conda install dynamic-tensor
```

Or install from source:

```bash
git clone https://github.com/eurekazheng/dynamic-tensor.git
cd dynamic-tensor
# build the package
python setup.py sdist bdist_wheel
pip install -e .
```

Usage:

```python
import densor
d = densor.dt([[1, 2], [3, 4]])
d[2, 1:3, [2, 3]] = 5.6
print(d, d.shape)

# Expected output:
# [[[1.  0.  0.  0. ]
#   [2.  0.  0.  0. ]
#   [0.  0.  0.  0. ]]
# 
#  [[3.  0.  0.  0. ]
#   [4.  0.  0.  0. ]
#   [0.  0.  0.  0. ]]
# 
#  [[0.  0.  0.  0. ]
#   [0.  0.  5.6 5.6]
#   [0.  0.  5.6 5.6]]] (3, 3, 4)

# Helper: convert a list to tensor when possible
densor.tensorify([[1, 2], [3, 4]])    # return ndarray
densor.tensorify([[1, 2], [3, 4, 5]]) # return False
```

## Rationale

The underlying data structure of `densor.dt` is `numpy.ndarray` `_a`. Upon a `__setitem(idx, val)__` call, the following preprocessing is done:

1. Determine the target shape.
2. Based on target shape, (potentially) expand the dimension of `_a`.
3. (Optional) Based on `val` dtype, (potentially) change the dtype of `_a`.
4. Based on target shape, (potentially) change the size of `_a` at each dimension.

Refer to `src/densor.py` for more details.