semvec/pypi-packages huggingface dataset:
ingestion-game 0.1.3
The ingestion game CLI
Requires Python: >=3.11

# The Ingestion Game

The Ingestion Game consists of:
1. A data file with a varying number of entries containing some data. It is shaped as a CSV where each row has
    an arbitrary number of `key=value` pairs separated by comma.
    ```
    key1=value1,key2=value2
    key3=value3
    key4=value4,key5=value5,key6=value6
    ```
2. Not all `key`s are always important! Each time we play the game, the keys to process can be different. The rest
    are just considered noise. We want to ingest all the important keys.
3. All important keys are always going to be present in the data rows of the input file.
4. Each `key` supports a specific data type. We should only process rows where the values match the expected datatype of each key.
5. Each row consists of an Entity of a given type. The type will be informed as `type=T` in the data. `type` is
    always considered as an important key and we can assume it is a `str`.
6. Entities have hierarchies defined in the games' rules. For example, given the rule `A -> B`, we cannot
    process any Entity of type `B` until we have processed all Entities of type `A`.

Your task is to win the Ingestion Game with the following rules:

- The important keys are `id:int`, `name:str`, `food:str` and `type:str`.
- Entities follow the hierarchy `A -> B -> C`.

The solution must be coded in Python and you can use any public libraries. The solution must be an CLI that outputs
the processed data to `stdout` in CSV format following the important keys, e.g.,:

```
id,name,food,type
1,levy,veggies,A
2,lima,pizza,A
3,john,fish,B
```

We are going to provide a data file with the keys and hierarchies mentioned above, but your CLI should accept any
important keys and hierarchies as inputs. You can see an example on input data in the provided `input.txt`.

## 🤓 We value in the solution

- Good software design
- Proper documentation
- Compliance to Python standards and modern usages (e.g.: [PEP8](https://peps.python.org/pep-0008/))
- Proper use of data structures
- Ergonomy of the command line interface
- Setup/Launch instructions if required

# Solution

Install using pip:
```bash
pip install ingestion-game
```

## Run
Help:
```bash
ingestion_game --help
```

Parameters:
- IMPORTANT_KEYS: [required] separate by commas without spaces
  example: ```id:int,name:str,food:str,type:str```
- HIERARCHY: [required] separate by commas without spaces
  example: ```A,B,C```
- PATH: [required] path of the input file
  example: ```/files/input.txt```

Example:
```bash
ingestion_game id:int,name:str,type:str A,B,C /file/input.txt
```
fake-harmony-module 0.0.2
Fake harmony module
Keywords: python,toonboom,harmony


This repository contains a fake ToonBoom package featuring a Harmony module that includes all the classes used within Harmony's Python interface. Its primary purpose is to provide autocompletion, access to docstrings, and accurate type hints in your preferred IDE.

All classes have been written based on Harmony's Python documentation, which can be found at <https://docs.toonboom.com/help/harmony-22/scripting/pythonmodule/index.html>.

Please note that this fake module may contain inconsistencies, missing return types, and typos. Unfortunately, most of these issues stem from faithfully transcribing Harmony's flawed documentation.
centresurv 0.1.2
For assessment of service distribution in an area.
Requires Python: >=3.6

Centresurv 0.1.2
---------

Geoserv is a python package that allows for the easy assessment of distribution of services in an area.
It also allows for easy integration with population distribution data.

---------

DEPENDENCIES:

osmnx, networkx, pandas, sqlite3, python_igraph, numpy, matplotlib, geopandas, folium

Installation of osmnx, igraph and geopandas via pip is often problematic, particularly on Windows OS. It may be possible
to do so using conda, or to manually install from the wheelfiles, as shown in this tutorial:
https://geoffboeing.com/2014/09/using-geopandas-windows/

N.B. If following this method for installation of geopandas, it is then possible to simply pip install osmnx

Alternatively, it may be more convenient to use windows subsystem for linux.
---------

Geoserv consists for four main modules:

postcode_setup -> This module contains all the functions required to import and save a graph for a given area of
                  interest, taking the map data from the Open Street Map APIs.

                  Given a csv file containing postcode data for the same area (for the UK available from:
                  https://www.doogal.co.uk/), a database can be created and shortest path analysis performed.

analyse -> This contains functions to calculate very basic statistics regarding the shortest path analysis completed
           such as average distances, total person-meters in an area, and the gini coefficient for the entire area

maps -> This uses the data generated in the analyse module to create high quality visualisations of the data on
        choropleth maps using folium, and saves these as html files. The boundaries for use in this must be downloaded
        as shapefiles (for UK these are available from: http://geoportal.statistics.gov.uk/ or https://data.gov.uk/)

        N.B. The shapefiles used must have a column entitled "name" containing the same sub-area names as are found in
             the database. It is likely that these will require some degree of cleaning in order to match

---------
ACKNOWLEDGEMENTS:

This package builds upon and integrates the functionality of several much better packages. Much of the
functionality represents only small incremental modifications on the dependencies listed above, in particular osmnx.
lowess-grouped 0.0.7
Apply groupwise lowess smoothing to a dataframe
Requires Python: >=3.8

# Lowess Grouped

**Apply groupwise lowess smoothing to a dataframe.**

Smooth data for each category using the [lowess](https://en.wikipedia.org/wiki/Local_regression) (aka loess) algorithm.
You can use this code for all forms of data that should be smoothed independently by group:

![lowess-grouped-example](https://raw.githubusercontent.com/lukiwieser/lowess-grouped/main/docs/lowess-grouped-example.svg)
*Figure 1: Smoothed temperature data for each region*


## Usage

Install the package (Python 3.8 or higher):

```console
pip install lowess-grouped
```

Import the package and call the function `lowess_grouped` with your dataframe `df`. Use the parameter `frac` to control the strength of the smoothing:

```python
from lowess_grouped.lowess_grouped import lowess_grouped

df_smoothed = lowess_grouped(df, 
                             x_name="year", 
                             y_name="temperature_anomaly",
                             group_name="region_name", 
                             frac=0.05)
```

For a detailed example, refer to the notebook [temperature-example.ipynb](https://github.com/lukiwieser/lowess-grouped/blob/main/example/temperature-example.ipynb).


## Testcases

Tests are defined in the folder `tests`. To run them manually, follow these steps: 

1) Download the [source code](https://github.com/lukiwieser/lowess-grouped) from GitHub.

2) Install package locally by executing the following command in the project folder:
    ```console
    pip install -e .
    ```

    You might need to upgrade your version of pip for this to work:
    ```console
    pip install --upgrade pip
    ```

3) Run the tests:
    ```console
    python ./tests/test_lowess_grouped.py -v
    ```


## Motivation

Smoothing data can greatly improve the interpretability of visualizations.
One commonly used method is lowess, also knows as loess, sometimes also referred as *Savitzky–Golay filter*.

However, the built-in lowess function in Statsmodels (a popular statistics package) applies smoothing to the entire dataframe.
This can lead to undesirable results when you need independent smoothing for multiple groups (e.g., temperature data by regions).

This package was developed to address this limitation and provide some convenience, like getting a dataframe with column names back, instead of unnamed numpy arrays.
Internally it still uses Statsmodels.


## Attribution

This project builds upon the lowess function from [statsmodels](https://www.statsmodels.org).
The temperature data used in the example notebook and testcases is from [Berkley Earth](https://berkeleyearth.org/data/), and licensed under [Creative Commons BY-NC 4.0 International](https://creativecommons.org/licenses/by-nc/4.0/).