semvec/pypi-packages huggingface dataset:
noconf 1.0
Component-based configuration for everyone!

======
noconf
======

Key features
============

1. **Flexible configuration**: noconf allows you to configure your
   Python applications using configuration files that use Python
   syntax.

2. **Multiple configuration files**: noconf allows you to split your
   configuration across multiple files, making it easier to manage and
   update your configuration as your application grows.

3. **Configuration referencing**: noconf allows you to reference other
   parts of your configuration from within your configuration,
   avoiding duplication and keeping your configuration DRY (Don't
   Repeat Yourself).

4. **Component-based programming**: noconf enables you to initialize
   classes using your configuration, making it easy to compose complex
   systems out of smaller, reusable components. This promotes code
   reuse and maintainability.

Usage
=====

At a minimum, noconf allows us to read configuration that's stored in
files with Python syntax, where the file contains exactly one top
level dictionary.

Let's first write a very simple config file:

>>> config1_fname = folder / "config1.py"
>>> config1_fname.write_text("""
... {'key1': 'value1', 'key2': ['value2']}
... """)
40

>>> from noconf import load
>>> load(config1_fname)
{'key1': 'value1', 'key2': ['value2']}

We can also chain configuration files, that is, load multiple
configuration files and merge them, where contents of the files later
in the list of files to load will take precedence:

>>> config2_fname = folder / "config2.py"
>>> config2_fname.write_text("""
... {'key1': 'new', 'key3': {'__copy__': 'key2'}}
... """)
47
>>> load((config1_fname, config2_fname))  # a tuple of config files
{'key1': 'new', 'key2': ['value2'], 'key3': ['value2']}

Notice that in the above example, we also used a `'__copy__'` feature,
which allows us to refer to other parts in the configuration, and to
avoid duplication.

We can also instantiate classes directly from the configuration.
Let's create a configuration file that instantiates a Python logging
FileHandler class.  We're also going to configure the FileHandler with
a filename that's passed as an environment variable.  We use the
special `environ` variable in noconf to access environment variables:

>>> setenv("LOGFILE", str(folder / "mylogfile.txt"))

>>> config3_fname = folder / "config3.py"
>>> config3_fname.write_text("""
... {
...     'handlers': [
...         {
...             '!': 'logging.FileHandler',
...             'filename': environ['LOGFILE'],
...         },
...     ],
... }
... """)
135
>>> config = load(config3_fname)
>>> filehandler = config['handlers'][0]

>>> from pathlib import Path
>>> Path(filehandler.baseFilename).parts[-1]
'mylogfile.txt'
number-spacy 0.0.1
A spaCy extension for enhanced number entity recognition and extraction as structured data.

[![GitHub Stars](https://img.shields.io/github/stars/wjbmattingly/number-spacy?style=social)](https://github.com/wjbmattingly/number-spacy)
[![PyPi Version](https://img.shields.io/pypi/v/number-spacy)](https://pypi.org/project/number-spacy/0.0.1/)
[![PyPi Downloads](https://img.shields.io/pypi/dm/number-spacy)](https://pypi.org/project/number-spacy/0.0.1/)

# Number spaCy

![number spacy logo](https://github.com/wjbmattingly/number-spacy/blob/main/images/number-spacy-logo.png?raw=true)

Number spaCy is a custom spaCy pipeline component that enhances the identification of number entities in text and fetches the parsed numeric values using spaCy's token extensions. It uses RegEx to identify number entities written in words and then leverages the [word2number](https://github.com/akshaynagpal/w2n) library to convert those words into structured numeric data. The output numeric value is stored in a custom entity extension: `._.number`.

This lightweight component can be seamlessly added to an existing spaCy pipeline or integrated into a blank model. If using within an existing spaCy pipeline, ensure to insert it before the NER model.

## Installation

To install Number spaCy, execute:

```bash
pip install number-spacy
```

## Usage

### Integrating the Component into your spaCy Pipeline

Begin by importing the `find_numbers` component and then integrating it into your spaCy pipeline:

```python
import spacy
from number_spacy import find_numbers

# Initialize your preferred spaCy model
nlp = spacy.blank('en')

# Integrate the component into the pipeline
nlp.add_pipe('find_numbers')
```

### Text Processing with the Pipeline

Post the component addition, you can process text as you typically would:

```python
doc = nlp("I have three apples. She gave me twenty-two more, and now I have twenty-five apples in total.")
```

### Retrieving the Parsed Numbers

You can loop through the entities in the `doc` and access the specific number extension:

```python
for ent in doc.ents:
    if ent.label_ == "NUMBER":
        print(f"Text: {ent.text} -> Parsed Number: {ent._.number}")
```

This should output:

```
Text: three -> Parsed Number: 3
Text: twenty-two -> Parsed Number: 22
Text: twenty-five -> Parsed Number: 25
```
fixer-currency 0.1.0
A Python client for Fixer API - a currency conversion API
Requires Python: >=3.7

# Fixer Currency

A Python module for the Fixer API for currency conversion.

[![PyPI - Version](https://img.shields.io/pypi/v/fixer-currency.svg)](https://pypi.org/project/fixer-currency)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fixer-currency.svg)](https://pypi.org/project/fixer-currency)
![Github Build Status](https://github.com/jfrid/fixer-currency/actions/workflows/build-and-inspect-main.yml/badge.svg)

-----

**Table of Contents**

- [Module Description](#module-description)
- [Installation](#installation)
- [License](#license)
- [Account and API Key](#account-and-api-key)
- [Usage](#usage)

## Module Description

Fixer API (formerly known as Fixer.io) is a JSON API for current and
historical foreign exchange rates published by the European Central Bank.

The rates are updated daily around 13:00 CET.

This module is based on the module [fixerio](https://pypi.org/project/fixerio/)
originally created by by Adrián Matellanes.

## Installation

```console
pip install fixer-currency
```

## License

`fixer-currency` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

## Account and API Key

All calls to the Fixer API requires an API key. To acquire an API key you need
to first register for an account on [API Layer]. When logged in, go to the
[Fixer API page] and subscribe to one of the plans. The free plan allows for
quite a number of requests per month and has no other restrictions as to what
can be requested through the API.

## Usage

All requests to the Fixer API should be made using an instance of the `FixerClient` class.

```python
from fixer_currency import FixerClient

fxr = FixerClient("<YOUR API KEY>")
```

The `FixerClient` object always has a base currency defined for conversions and
the default currency is EUR. Another base currency can be specified with an
argument:

```python
fxr = FixerClient("<YOUR API KEY>", "USD")
```

List all available currencys that can be used as base or target in a conversion:

```python
>>> fxr.available_currencies()
{'success': True, 'symbols': {'AED': 'United Arab Emirates Dirham', 'AFN': 'Afghan Afghani', 'ALL': 'Albanian Lek', ... }}
```

Get latest rate(s) for one or more currencies:

```python
>>> fxr.latest(symbols=["SEK", "NOK"])
{'success': True, 'timestamp': 1692526623, 'base': 'EUR', 'date': '2023-08-20', 'rates': {'SEK': 11.938802, 'NOK': 11.611995}}
```

Get historical rates for any day since 1999:

```python
>>> import datetime
>>> fxr.historical_rates(datetime.date(2022, 1,1), symbols="SEK")
{'success': True, 'timestamp': 1641081599, 'historical': True, 'base': 'EUR', 'date': '2022-01-01', 'rates': {'SEK': 10.291223}}
```

[API Layer]: https://apilayer.com/
[Fixer API page]: https://apilayer.com/marketplace/fixer-api
django-agent 1.0.1
A Django app that provides an API for executing shell commands and retrieving their output
Requires Python: >=3.10

# Django Agent


This is a Django app that provides an API for executing shell commands and retrieving their output.

## Quick start

*  Add **django_agent** to your **INSTALLED_APPS** setting like this
```
INSTALLED_APPS = [
    ...,
    "django_agent",
]
```
* Include the  **django_agent** URLconf in your project **urls.py** like this
```
path("agent/", include("django_agent.urls")),
```
   


* Add **AGENT_TOKEN**  to your project **settings.py** like this
```
...
AGENT_TOKEN="my-agent-token"
```
altcos-common 2.0.0
Components for working with altcos
Requires Python: >=3.10

# altcos-common

Библиотека для удобного взаимодейтсвия с `altcos`-репозиториями.

# Примеры

[Информация о последнем коммите](examples/last_commit_info.py)

[Получение коммита по версии](examples/commit_by_version.py)
abbreviations-py 0.2
A simple package to replace abbreviations/contractions by full forms. Also works with slangs like b4 (before)

# abbreviations_py

`abbreviations_py` is a Python package that provides a convenient way to abbreviate and normalize text. It offers functionality to clean text by replacing common abbreviations with their full forms, removing punctuations and hashtags.

## Installation

You can install `abbreviations_py` using `pip`:

```bash
pip install abbreviations-py
```

## Usage

```python
from abbreviations_py.textes.abbreviator import fix, update_abbreviations

# Fix abbreviated text
input_text = "I'll txt you when you're back, ttyl! #BonVoyage"
result = fix(input_text)
print(result)
# Output: I will text you when you are back talk to you later

# Update abbreviation mappings
new_mappings = {
    "ttyl": "talk to you later",
    "txt": "text",
    # Add more mappings here
}

update_abbreviations(new_mappings)
```

## Contributing

Contributions are welcome! If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.

## License

This project is licensed under the [MIT License](LICENSE).

---

Created by [Prajwal Khairnar](https://github.com/prajwalkhairnar)
face_processor 1.6
Transform faces for use in RSVP experiments
Requires Python: >=3.5

# face-processor
 
Tool to process faces for psychophysics experiments. 

Adjust position of faces
make the images equiluminant

TODO: Describe module

Bainbridge, W. A., Isola, P., & Oliva, A. (2013). The Intrinsic Memorability of Face Photographs. Journal of Experimental Psychology: General, 142(4), 1323 - 1334.

# usage

## process distractors

This is done once to generate our distractor/control faces from the Bainsbridge database:

```python process_distractors.py```

## process probe

Place original photos in `stimuli/original/probes`. Crop the photo to leave a small margin around the top of the head, the ears and then chin. Then run (e.g.,):

```python process_probe.py ../original/probes/001.jpeg 1 M```