semvec/pypi-packages huggingface dataset:
entity-classification 0.1.3
Perform Intent Classification using a list of Entities
License: MIT
Requires Python: >=3.8.5,<4.0.0
Keywords: nlp,nlu,ai,classification,intents

# entity-classification

Perform Entity Classification via two inputs: `entity_names: list` and `input_tokens: list`

Assume you wish to classify `network_topology` and you have these tokens extracted from your text:
```python
[
    'edge',
    'network',
    'moderate',
    'cat5',
    'topology',
    'locate'
]
```

Use this code
```python
from entity_classification import classify

classify(entity_names=['network_topology'], input_tokens=input_tokens)
```

The result will be
```python
{
    'result': ['network_topology'],
    'tokens': ['network', 'topology']
}
```
pyccsi 1.0.1
Python package for request and download data from CCSI
License: MIT

ptr-metagen

### Description 
Python package for request and download data from CCSI 

### Install
```
pip install pyccsi
```

### Usage

Import of the downloader class
```
from pyccsi import CCSIDownloader
```
Initialization of the downloader class. Class expecting only one parameter that is the base/host url of CCSI server instance
```
ccsi = CCSIDownloader(host_url="http://localhost:5000")
```
Downloader method 'send_request' send the request on the CSSI resource endpoin vis. host_url/:resource/... 

Available resources name can be get via get request on the resource parameters endpoint vis. host_url/resources/parameters

Parameter params is a dict of resource parameters in the form of dictionary od pydantic base model. Parameters of 
given resource endpoint are show on resource OpenSearch description dokument vis. host_url/:resource/atom/search/description.xml
```
ccsi.send_request(resource=resource, params=params)
```
Send request can return list of the record requested from the CCSI for aditional sorting and manipulation

####Example of params dictionary
resource: cds_er5
```
    {
        'timeStart': '2021-01-01',
        'timeEnd': '2021-01-10',
        'bbox': '25.067713534286536,35.298035029324204,25.193195594830012,35.347934920842974',
        'custom:camsDataset': 'total_column_water_vapour,10m_u_component_of_wind',
        'custom:hour': '03:00,06:00',
        'custom:format': 'grib'
    }
```
Second downloader method  download accept the path of the folder where the data will be downloaded. 
```
ccsi.download(path=output_directory)
```
Optionaly custom list of the records can be set in the method
```
ccsi.download(path=output_directory, records=records)
```
fluentfs 0.4.0
Functional and fluent interface for filesystem interactions
License: MIT

# fluentfs

The `fluentfs` library provides a functional and [fluent](https://en.wikipedia.org/wiki/Fluent_interface) interface for filesystem interactions.

This library is usable and tested, but the API is currently not stable, a lot of features are still missing etc.

In summary - **try it out, but (obviously) don't use it for anything in production**.

## Requirements

You need `Python >= 3.9` for this library.

## Installation

You can install fluentfs using the `pip` package manager:

```shell
pip install fluentfs
```

## Code examples

Let's say you need to get the total number of lines of all `txt` files in the current directory (including its subdirectories).
The `fluentfs` library allows you to express this functionally as following:

1. **Filter** the files by the "txt" extension
2. **Map** the files to their line counts
3. **Reduce** the line counts to their sum

This is how it looks in code:

```python
import fluentfs as fs

total_txt_line_count = (
    fs.Dir(".")                         # get the current directory
        .files                          # get an iterator for the (regular) files in the current directory
        .filter_extension("txt")        # filter the files by the txt extension
        .text_file_iterator()           # all the files should now be text files -> obtain a text file iterator to enable text file functions
        .map_line_count()               # map every file to its line count
        .sum()                          # sum the line count
)
print(total_txt_line_count)
```

The library is very flexible, allowing you to write both short and long forms for most properties:

```python
import fluentfs as fs

# Short form (for when you quickly need to prototype something)
fs.Dir(".").files.filter_ext("txt").t().map_lc().sum()

# Long form (for when you need to use the library in a codebase)
(
    fs.Dir(".")
        .files
        .filter_extension("txt")
        .text_file_iterator()
        .map_line_count()
        .sum()
)
```

The `fluentfs` library is very general.
If you need to perform an operation that is currently not present, simply call the respective higher-order functions with your own callables.
For example here is how we could perform our task by explicitly calling the respective higher-order functions:

```python
import fluentfs as fs

(
    fs.Dir(".")
    .files
    .filter(lambda f: f.extension == "txt")
    .text_file_iterator()
    .map_self(lambda f: f.line_count)
    .reduce(lambda x, y: x + y, 0)
)
```

## Documentation

You can have a look at the [basics](https://uhasker.github.io/fluentfs/basics.html) if this is the first time you are using this library.

You can have a look at the [guide](https://uhasker.github.io/fluentfs/guide.html) if you wish to go more in-depth.

You can have a look at the [recipes](https://uhasker.github.io/fluentfs/recipes.html) if you have a specific task you want to accomplish and want to look at some fluent chains that accomplish this or a similar task.

You can also have a look at the [API documentation](https://uhasker.github.io/fluentfs/api.html).