semvec/pypi-packages huggingface dataset:
ren-algorithm 0.1.6
A collection of machine learning algorithms
Requires Python: >=3.6

# ML_algorithms

A collection of machine learning algorithms implemented in Python. This package includes implementations for various supervised learning models such as XGBoost, Decision Trees, Random Forest, K-Nearest Neighbors (KNN), and Linear SVM, Linear regression, Logistics Regression . Each algorithm is organized in its own module for easy use and experimentation.

## Features

- **XGBoost Regressor**: Implementation of XGBoost regression with helper functions for model building.
- **Decision Trees**: Code for constructing decision trees used by various algorithms.
- **Random Forest Regressor**: Ensemble method combining multiple decision trees for robust predictions.
- **K-Nearest Neighbors (KNN)**: A simple and effective algorithm for classification and regression.
- **Linear SVM**: Linear Support Vector Machine implementation for classification tasks.
- **Linear Regression**: implements sinmple and multivariate linear regression algorithm.
- **Logistic Regression**: implements logistics regression.

## Installation

Install the package directly from PyPI using pip:

```bash
pip install ren-algorithm==0.1.6
smartwrap 0.0.2
A smart text wrapper
Requires Python: >=3.8

`smartwrap` is an extension of the standard library [`textwrap`](https://docs.python.org/3/library/textwrap.html) which enables balanced text wrapping. 

Wrapped text is balanced when the number of characters across all rows is minimized, while keeping the number of rows identical to that of unbalanced wrapping. Note that this is numerical balancing – not optical balancing, which takes more factors into consideration such as kerning and letter size.

## Usage

### Example

```python
UDHR = """All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood."""

$ textwrap.wrap(UDHR)
['All human beings are born free and equal in dignity and rights. They',
 'are endowed with reason and conscience and should act towards one',
 'another in a spirit of brotherhood.']

$ smartwrap.wrap(UDHR, balanced=True)
['All human beings are born free and equal in dignity and',
 'rights. They are endowed with reason and conscience and',
 'should act towards one another in a spirit of brotherhood.']
```

### Hint

`smartwrap` is most useful when wrapping short pieces of text which could flow into multiple rows depending on the container size. To prevent awkward splitting of the text into one long row and one short row, `smartwrap` balances the number of letters between the rows. Some cases include labels on legends and buttons, quoted statements, etc.

```py
# Example: a pie chart has a label 'Social and cultural rights'; labels cannot be longer than 20 characters.

$ textwrap.wrap("Social and cultural rights", width=20)
['Social and cultural', 'rights']

$ smartwrap.wrap("Social and cultural rights", balanced=True, width=20)
['Social and', 'cultural rights']
```

Note that `smartwrap` can be used like `textwrap`. It returns the same outputs when `balanced` flag is set to False. Also it accepts the same arguments and has the same methods.

```python
$ smartwrap.wrap(UDHR) # no difference to `textwrap`
['All human beings are born free and equal in dignity and rights. They',
 'are endowed with reason and conscience and should act towards one',
 'another in a spirit of brotherhood.']

$ smartwrap.wrap(UDHR, balanced=True, width=50) # width arg and other args available
['All human beings are born free and equal in',
 'dignity and rights. They are endowed with',
 'reason and conscience and should act towards',
 'one another in a spirit of brotherhood.']

$ smartwrap.fill(UDHR, balanced=True, width=50) # .fill() and other methods available
'All human beings are born free and equal in\ndignity and rights. They are endowed with\nreason and conscience and should act towards\none another in a spirit of brotherhood.'
```
pyterrier-ciff 0.2.1
PyTerrier integrations with CIFF
Requires Python: >=3.10

# CIFF + PyTerrier

The Common Index File Format (CIFF) represents an attempt to build a binary data exchange format for open-source search engines to interoperate by sharing index structures.

-- [CIFF Project](https://github.com/osirrc/ciff)

[pyterrier-ciff](https://github.com/seanmacavaney/pyterrier-ciff) gives access to [CIFF](https://github.com/osirrc/ciff) files. It provides the following core functionality:

- Build CIFF indexes from built indexes. [example](https://pyterrier.readthedocs.io/en/latest/ext/pyterrier-ciff/index.html#building-from-an-index)
- Build CIFF indexes from learned sparse retrieval models.
- Parse CIFF files to get the postings and document records. [example](https://pyterrier.readthedocs.io/en/latest/ext/pyterrier-ciff/index.html#pyterrier_ciff.CiffIndex.records_iter)
- Share and load CIFF files to/from HuggingFace datasets. [example](https://pyterrier.readthedocs.io/en/latest/ext/pyterrier-ciff/index.html#building-from-an-index)
- Load files from the [CIFF Hub](https://github.com/pisa-engine/ciff-hub). [example](https://pyterrier.readthedocs.io/en/latest/ext/pyterrier-ciff/index.html#loading-ciff-from-the-ciff-hub)

## Quick Start

You can install `pyterrier-ciff` with pip:

```console
pip install pyterrier-ciff
```

## Documentation

Full documentation can be found in the [PyTerrier Docs](https://pyterrier.readthedocs.io/en/latest/ext/pyterrier-ciff/index.html).
aws-sso1 0.0.2241904
AWS SSO utility
Requires Python: >=3.11
Keywords: aws sso

## AWS Single Sign On

## Deprecation Notice
If your AWS organization has been configured with Identity Center you should use the `aws sso` command that's
included in the AWS cli. After going through the configuration step your `~/.aws/config` might look like the following,
where `example` refers to the name of your company or organization. You can define multiple AWS profiles linked to
one sso session.

```text
[sso-session example]
sso_start_url = https://example.awsapps.com/start
sso_region = us-east-1

[profile example-stage-admin]
sso_session = example
sso_account_id = REDACTED
sso_role_name = AdministratorAccess
region = us-east-1
output = json
```

The `aws sso configure` and `aws sso login` actions attempt to open your default web browser and initiate the login process
for your AWS org. For more information see their official documentation:
- https://docs.aws.amazon.com/cli/latest/userguide/sso-configure-profile-token.html


### Example Usage
```shell
pip install aws-sso
aws-sso site add --domain example.com --username {your_name}
aws-sso discover --domain example.com --skip-names
aws-sso login --domain example.com
```

```shell
pip install awscli
cd path/to/project
echo "export AWS_PROFILE=sbx" > .envrc
direnv allow
aws s3 ls
```

### Code Quality
Run the following commands to analyze the project with sonar.
```shell
docker run -d --name sonarqube -p 9000:9000 sonarqube
nosetests --with-xunit --with-coverage --cover-xml
sonar-scanner -D project.settings=cicd/sonar-project.properties
```

### Links
- [blog][blog]
- [code][code]

[blog]: https://aws.amazon.com/premiumsupport/knowledge-center/adfs-grant-ad-access-api-cli/
[code]: https://awsiammedia.s3.amazonaws.com/public/sample/SAMLAPICLIADFS/0192721658_1562696757_blogversion_samlapi_python3.py
nextdata 0.1.23
NextData is a framework for building data pipelines with a focus on simplicity and scalability.
Requires Python: >=3.9

# What is NextData?

NextData answers the question: "What would a nextjs for data worfklows look like?"

It is a framework that provides convention over configuration for data workflows.

A "data directory" is the single source of truth for your data. It is a directory that contains all of your data, and all of your code that operates on that data.

# How to use NextData

## Installing NextData

```bash
pip install nextdata
```

This will install the NextData framework and the `ndx` command line tool.

## Creating a new NextData project

```bash
ndx create-ndx-app my_project
```

### Configuring your project

NextData uses Pulumi under the hood to manage your infrastructure. Make sure you have pulumi installed and configured. You'll need AWS credentials in your environment, but NextData will confiure an IAM role specifically for Pulumi to use that only has access to the resources you need.

### Running your project

```bash
ndx dev
```

The dev server starts 4 processes:

1. A Pulumi stack that manages your infrastructure
2. A watch dog that watches your data directory and reruns your pulumi stack when you make changes
3. A FastAPI server that serves the NextData API
4. A NextJS server that serves the NextData Dashboard

In the future, this can be dockerized so you can self host just the components you need.

### Adding data to your project

Much like the app router in NextJS, NextData uses the `data directory` to represent your data. When you hadd a directory to your data directory, NextData will automatically generate an S3 table for you.

NextData also checks for certain magic files in each data table directory to determine how to process the data.

For example, adding an `etl.py` file will tell NextData to configure a Glue job to process the data. You only need to provide a connection name, and NextData will use the connection to read and write data to S3 using sensible defaults. Of course, you can customize the ETL script if you want using the `@glue_job` decorator.

Speaking of connections, NextData uses the `connections` directory to represent your data sources. Each connection is a set of credentials and configuration for a data source. NextData currently supports arbitrary connections through JDBC and DSQL, but in the future will support more data sources like Snowflake, BigQuery, etc.

## NextData Dashboard

The NextData Dashboard is a NextJS app that provides a UI for you to explore your data. It is powered by the NextData API, which is a FastAPI server that you can use to build your own custom APIs.

The Dashboard is where you can build your own queries, visualizations, and data products.