semvec/pypi-packages huggingface dataset:
elevenfiftynine_python_core_lib 0.1.0
This is a template repository for Python projects that use Poetry for their dependency management.
Requires Python: <4.0,>=3.8

# elevenfiftynine-python-core-lib

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

This is a template repository for Python projects that use Poetry for their dependency management.

- **Github repository**: <https://github.com/fpgmaas/elevenfiftynine-python-core-lib/>
- **Documentation** <https://fpgmaas.github.io/elevenfiftynine-python-core-lib/>

## 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:fpgmaas/elevenfiftynine-python-core-lib.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/fpgmaas/elevenfiftynine-python-core-lib/settings/secrets/actions/new).
- Create a [new release](https://github.com/fpgmaas/elevenfiftynine-python-core-lib/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).
python-barn 0.11.0
A wrapper for pip, to give better utils to python projects dependency management
Requires Python: >=3.9

# barn

barn is a Python-based command-line interface (CLI) tool that simplifies package management by providing an intuitive set of commands.
It was inspired by the **yarn** counterpart from Javascript.
Hence the interface was kept as similar as possible, so that if you are familiar with yarn you should pickup barn relatively fast.

> **Note**
> Barn is just a pip wrapper, so package resolution is still completely
> up to pip and your installed pip version

## Features

- Install packages
- Add new packages
- Initialize new projects with interactive prompts
- Ability to define script scoped to your project, like you would do with a package.json

### ⚠️ A small invite to caution

Barn is still in development and can be unstable.
More over:

- It currently only supports python 3.9 and it is only officially tested on 3.9.13
- It still lacks core feature that hopefully will be added soon

## How to use

You can install barn directly with the following pip command:

> **Note**
> You are encouraged to install barn globally on your system

```
pip install python-barn
```

#### You can initialise an empty directory to be a barn project by running:

```
barn init
```

This will launch an interactive prompt asking for details such as project name, description, author, etc.

In case your project already exists and it's not an empty folder, you can create the `project.yaml` file with the following content:

```
name: my-project
description: Some description
version: 0.1.0
author: your-name or your team name
scripts:
  - start: python ./main.py
  - test: echo "Not implemented"
license: your-license
```

#### Install project dependencies

```
barn
```

or

```
barn install
```

#### Add a new package:

```
barn add <package-name>
```

#### Remove a package:

```
barn remove <package-name>
```

#### To setup custom scripts

In the project.yaml, you can specify bash scripts by adding to the scripts section:

```
scripts:
  - start: python ./main.py
```

Once you have your script defined you can run:

```
barn <script-name>
```

In this case:

```
barn start
```

This will run your script in the context of the project, with the correct python version and pointing to the correct virtual environment

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
with-coordination 0.0.1
Declarative coordinated multiple views for Jupyter Widgets
Requires Python: >=3.8

# with-coordination

declarative coordinated multiple views for Jupyter Widgets

```sh
pip install with-coordination
```

## usage

```python
import ipywidgets

# create a set of widgets
slider1 = ipywidgets.FloatSlider(description='Slider 1')
slider2 = ipywidgets.FloatSlider(description='Slider 2')
slider3 = ipywidgets.FloatSlider(description='Slider 3')

# prepare an output area with arrangement of widgets
ipywidgets.VBox([slider1, slider2, slider3])
```

```python
from with_coordination import Coordination

# create a coordination context
with Coordination() as c:

  # define a coordination type
  with c.type("sliderValue") as t:

    # add a scope with a set of widgets
    with t.scope("A", 10) as s:
      # alias maps the widget prop to the coordination type if they are different
      s.view(slider1, alias="value")

    with t.scope("B", 4.0) as s:
      s.view(slider2, alias="value")
      s.view(slider3, alias="value")


  # get the coordination configuration as json
  print(c.to_json()) # b'{"coordinationSpace":{"sliderValue":{"A":10,"B":4.0}},"viewCoordination":{"view_0": ...'
```

Alternatively, you can use use an existing configuration to create a coordination context.

```python
with open("config.json", "w") as f:
  f.write("""
  {
    "key": 1,
    "coordinationSpace": { "sliderValue": { "A": 0.5, "B": 0.75 } },
    "viewCoordination": {
      "slider1": { "coordinationScopes": { "sliderValue": "A" } },
      "slider2": { "coordinationScopes": { "sliderValue": "B" } },
      "slider3": { "coordinationScopes": { "sliderValue": "B" } }
    }
  }
  """)

with Coordination("config.json") as c:
    c.use_widget(slider1, view_id="slider1", aliases={"value": "sliderValue"})
    c.use_widget(slider2, view_id="slider2", aliases={"value": "sliderValue"})
    c.use_widget(slider3, view_id="slider3", aliases={"value": "sliderValue"})
```

## why

Managing coordinated multiple views is a complex task. This library provides an
ergonomic and declarative API to specify how widgets traits should be
coordinated.

**with-coordination** is based on the declarative JSON coordination
specification from
[`use-coordination`](https://github.com/keller-mark/use-coordination) and is
designed to work with [anywidget](https://anywidget.dev).

## development

this project is managed using [rye](https://rye-up.com/).

```py
rye run jupyter lab
```

rye manages testing, linting, and formatting.

```sh
rye test
rye lint
rye format
```

alternatively you can create a virtual environment and use an development installation. You will need to install `jupyterlab`.

```sh
python -m venv .venv
source .venv/bin/activate
pip install -e .
pip install jupyterlab
jupyter lab
```
scgraph-data 2.0.0
Large geograph data for the scgraph package.
Requires Python: >=3.6

# scgraph_data
[![PyPI version](https://badge.fury.io/py/scgraph_data.svg)](https://badge.fury.io/py/scgraph_data)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Large geograph data for the [scgraph](https://github.com/connor-makowski/scgraph) package. This package includes larger geographs that would be too large to include in the main scgraph package. These geographs include larger and more complete networks like the world highway and world railway networks. 

Please note that these geographs are simplified and are not 100% accurate. They are also not directional geographs and should not be used for navigation or any other safety critical applications.


## Setup

Make sure you have Python 3.6.x (or higher) installed on your system. You can download it [here](https://www.python.org/downloads/).

## Installation

```
pip install scgraph_data
```

## Included GeoGraphs

- world_highways_geograph:
    - What: World highway network from OpenStreetMap
    - Use: `from scgraph_data.world_highways import world_highways_geograph`
    - Attribution: [OpenStreetMaps](https://www.openstreetmap.org/)
    - Length Measurement: Kilometers
    - [World Highways Picture](https://raw.githubusercontent.com/connor-makowski/scgraph_data/main/static/world_highways.png)
- world_railways_geograph:
    - What: World railway network from OpenStreetMap
    - Use: `from scgraph_data.world_railways import world_railways_geograph`
    - Attribution: [OpenStreetMaps](https://www.openstreetmap.org/)
    - Length Measurement: Kilometers
    - [World Railways Picture](https://raw.githubusercontent.com/connor-makowski/scgraph_data/main/static/world_railways.png)
- world_highways_and_marnet_geograph:
    - What: World highway and marnet network joined by ports
    - Use: `from scgraph_data.world_highways_and_marnet import world_highways_and_marnet_geograph`
    - Attribution: [OpenStreetMaps](https://www.openstreetmap.org/)
    - Attribution: [searoute](https://github.com/genthalili/searoute-py)
    - Length Measurement: Kilometers
    - [World Highways and Marnet Picture](https://raw.githubusercontent.com/connor-makowski/scgraph_data/main/static/world_highways_and_marnet.png)
    - Note: These two networks are connected by ports, where each port is joined to each respective network by using the closest euclidian entry point.
    - [Used Ports Picture](https://raw.githubusercontent.com/connor-makowski/scgraph_data/main/static/world_highway_and_marnet_port_connections.png)
txboto3 0.1.1
Run Boto3 in Twisted withotut blocking
Requires Python: <4.0,>=3.10

# TXBOTO3

A boto3 compatible Twisted Library. Run your AWS calls in a Deffered that runs the boto3 call in a separate thread, not blocking
Twisted.

Currently all clients are supported.

# Usage

We aim to be as close as possible to the boto3 interface.

```
import txboto3
from twisted.internet.defer import inlineCallbacks
from io import BytesIO

class MyResource:
    def __init__(self):
        self.s3_client = txboto3.client("s3")

    @inlineCallbacks
    def get_file(self):
        temp_buffer = BytesIO()
        yield self.s3_client.download_fileobj("my_bucket", "my_file", temp_buffer)
        return temp_buffer

    @inlineCallbacks
    def put_object(self, file_obj):
        yield self.s3_client.put_object(Bucket="my_bucket", Key="my_file", Body=file_obj.read())
```

# Stability

Unstable. Needs more testing and not reccomended for production use without proper testing. If you find
any bug please fill an issue in this repository.