semvec/pypi-packages huggingface dataset:
enf 0.0.1
Chronolocate audio recorded in the UK
Requires Python: >=3.8

# enf
Chronolocate audio recorded in the UK - a lightly edited fork of https://github.com/robert/enf-matching packaged for PyPI.

## Install

```shell
pip install enf
```

## Call

```python
from enf import enf.match

enf.match(presumed_year, presumed_month, path_to_wav)
```
sicret 0.1.1
What happens in secret, stays in sicret.
Requires Python: >=3.9,<4.0

# Sicret - What Happens in Secret Stays in Sicret


## Overview
Sicret is a command-line utility tool designed to securely encrypt and decrypt directories. Using robust cryptography, it ensures the confidentiality of your data. 

The tool is user-friendly and operates exclusively through the command line, making it suitable for a variety of users who prefer a quick and secure way to protect their folders.

## Installation

To install Sicret, ensure you have Python installed on your system.

You can install Sicret using pip:

```bash
pip install sicret
```

## Usage
Sicret is straightforward to use with two primary commands: -e for encryption and -d for decryption.

### Encrypting a Directory
To encrypt a directory, use the following command:

```bash
sicret -e /path/to/folder
```

This will encrypt the specified folder, and the resulting encrypted file will have the extension .sicret.enc. 
The original folder will be deleted after encryption to ensure security.

### Encrypting a Directory
To decrypt a previously encrypted directory, use the command:

```bash
sicret -d /path/to/folder
```

Note that you do not need to specify the .sicret.enc extension; the tool automatically appends this to locate the encrypted file. 
The decrypted folder will be restored to its original state.

### Security
Sicret uses the Fernet symmetric encryption standard from the cryptography library, ensuring high security for your encrypted data.


### Disclaimer
While Sicret is designed with security in mind, it's important to remember that no encryption tool can offer absolute security. Users are advised to keep backups of their important data and use strong, unique passwords for encryption.

The developer of Sicret is not responsible for data loss or any potential security breaches.

### Contributing
Contributions to Sicret are welcome. Please feel free to fork the repository, make improvements, and submit pull requests.
python-cosmograph 0.1.1
Cosmograph is a  library for scheduling asynchronous tasks using the `apscheduler` library. It provides decorators to easily schedule tasks at specific times, intervals, or dates.
Requires Python: >=3.11,<4.0

# Cosmograph - Async Task Scheduler

Cosmograph is a  library for scheduling asynchronous tasks using the `apscheduler` library. It provides decorators to easily schedule tasks at specific times, intervals, or dates.

## Installation

```bash
pip install apscheduler
```

## Quick Start

```python
from scheduler import Cosmograph, time_schedule, interval_schedule, date_schedule, on_shutdown
```

Use Cosmograph and scheduling methods as needed

## Features

Schedule tasks at specific times using cron-like syntax.
Schedule tasks at regular intervals.
Schedule tasks to run at a specific date and time.
Gracefully shut down the scheduler when the application is shutting down.

## Usage

### Time Schedule

```python
@time_schedule(hour=12, minute=30)
async def my_scheduled_task():
    print("Task executed at 12:30 PM.")
```

### Interval Schedule

```python
@interval_schedule(minutes=15)
async def my_repeating_task():
    print("Task executed every 15 minutes.")

```

### Date Schedule

```python
@date_schedule(run_date="2023-01-01 00:00:00")
async def my_one_time_task():
    print("Task executed once at the specified date and time.")
```

### Graceful Shutdown

```python
# Perform this during application shutdown
on_shutdown()
```

## Contribution

Feel free to contribute by opening issues or creating pull requests. We welcome your feedback and contributions!

## License

This project is licensed under the MIT License AGPLv3 - see the LICENSE file for details.
txtar 0.1.1
Port of golang's txtar, a trivial tar-like format for unit tests
Requires Python: >=3.8,<4.0

# txtar

`txtar` is a Python reimplementation of Go's txtar format, a tool for bundling and managing multiple text files in a single archive.

## Features

- Parse `txtar` formatted text into structured data.
- Serialize structured data back into `txtar` format.
- Unpack `txtar` archives into the file system.


## Usage

### In unit tests

```python
from pathlib import Path
import os

def test_my_function():
    # Define the txtar structure for sysfs-like files
    txtar_content = """
-- sys/class/thermal/thermal_zone0/temp --
55000
-- sys/class/power_supply/BAT0/capacity --
45
-- sys/block/sda/size --
1024000
"""

    with MockFS.from_string(txtar_content):
        assert os.path.exists("/sys/class/thermal/thermal_zone0/temp")
        assert os.path.exists("/sys/class/power_supply/BAT0/capacity")
        assert os.path.exists("/sys/block/sda/size")

        assert Path("/sys/block/sda/size").exists()
```

### Reading a file
```python
from txtar import TxTar

content = "..."  # txtar formatted string
archive = TxTar.parse(content)
```

### Serializing to txtar Format

```python
from txtar import TxTar, File

archive = TxTar(
    comments=["Example txtar archive"],
    files=[File(name="example.txt", lines=["Hello", "World"])]
)
content = archive.serialize()
```

### Unpacking an Archive

```python
from pathlib import Path
from txtar import TxTar

archive = TxTar.parse("...")
archive.unpack_in(Path("/path/to/unpack"))
```

## Development

 * Install dependencies: `poetry install`
 * Run tests with `pytest`.

## Releasing

```
poetry publish --build --username __token__ --password $PYPI_PASSWORD
```
sdr-classifier 0.0.1
Package to create SDR Classifier
Requires Python: >=3.8

# Service Difficult Report (SDR) classifier package
This is the source code for SDR Classifier package that classifies SDR records for potential safety hazards.  The work is a collaboration between FAA and Boeing 

## Demo
![](https://github.com/Boeing/sdr-hazards-classification/blob/hai-branch/img/sdr_classifier.gif)

## Virtual Environment
It is highly recommended to use venv, virtualenv or conda python environments. Read more about creating virtual environments via venv
https://docs.python.org/3/tutorial/venv.html#creating-virtual-environments

## Build the whl file and pip install whl file 
Run the command in the root folder to create the whl file in the _dist_ folder
```
python setup.py bdist_wheel
pip install sdr_classifier-0.0.2-py3-none-any.whl
```

## Install sdr_classifier with pip
```
pip install sdr_classifier
```

## Example
Follow the code snippet below to test and call the prediction method from the Depressurization model

```
from sdr_classifier import sdr_api
import pandas as pd

my_model = sdr_api.SdrInferenceAPI()

#test the prediction method
my_model.test_sdr_depressurization_predictions()

df = pd.read_csv('./src/sdr_classifier/data/SDR_Example.csv')
records = df["Text"]
#pass in a record list for prediction
pred, probs = my_model.get_predictions(records)

df['Prediction'] = pred
df['Prob'] = probs

print(df.head(2))

print("Done")
```
EagleEyev3 0.0.25
Python client for Eagle Eye Networks APIv3 

# EagleEyev3 #

## Summary ##
This is a python package for working with the Eagle Eye Networks APIv3.  It takes some liberties with the API to make it more pythonic.  There is plenty of sugar sprinkled in to make it a little easier to use.


## Features ##
This is still a very early project that hasn't reached 1.0.0 yet.

### Included ###

- Login through Oauth2 flow
- Login with refresh_token
- Reseller account switching
- List of Cameras (attached, available, multi)
- List of Bridges
- List of Accounts
- List of Status Events for Cameras
- List of Videos (main, mp4) for Camera
- Get live preview image
- Get list of available feeds

### Coming Soon ###

- Download video (main, mp4)
- Get live video (hls)
- Get Thumbnail image
- Archive (files)
- VSP
- PTZ
- Event Subscriptions
- Alerts
- Notifications
- Tags


## Getting Started ##


Start by import the package and the config from settings (see the Settings File section below)

```
from EagleEyev3 import *
from settings import config
```

Make a new instance

```
een = EagleEyev3(config)
```


If you are going to use the Oauth2 login flow, construct the login url

```
base_url     =  "https://auth.eagleeyenetworks.com/oauth2/authorize"
path_url     =  f"?client_id={een.client_id}&response_type=code&scope=vms.all&redirect_uri={een.redirect_uri}"
login_url    =  f"{base_url}{path_url}"  }
``` 

Handle the callback from Oauth2 including the code, proceed to get access and refresh tokens

```
oauth_object = een.login_tokens(code)
```

Alternatively you can login using the refresh_token

```
een.login_tokens(code=None, cascade=True, refresh_token=<refresh_token>)
```

You'll probably want to get a list of cameras

```
een.get_list_of_cameras()
```

There are helpers to get online cameras

```
[i for i in een.cameras if i.is_online()]
```

and offline

```
[i for i in een.cameras if i.is_offline()]
```

You can get a live preview image

```
camera.get_live_preview()
```

You can get a list of all feeds
```
een.get_list_of_feeds()
```



## Settings File ##
There is file `settings.py` that is needed to run.  It should look similar to this:

```
config = {

	# Set up your application and get client id/secrete first
	# https://developerv3.eagleeyenetworks.com/page/my-application
	"client_id": "",
	"client_secret": "",

	# you will need to add approved redirect_uris in your application
	# this examples assumes you've added http://127.0.0.1:3333/login_callback
	# change the following variables if you did something different
	# Note: do not use localhost for server_host, use 127.0.0.1 instead
	"server_protocol": "http",
	"server_host": "127.0.0.1", 
	"server_port": "3333",
	"server_path": "login_callback",
}
```

You can create your application and setup credentials at: [https://developerv3.eagleeyenetworks.com/page/my-application-html](my applications).  You can also reach out to api_support@een.com for help.
area-calculator-dci1234 0.0.2
Calculate areas of geometrical figures
Requires Python: >=3.6

### :heavy_plus_sign: Task 2 - creating package on PyPI

Your task is to create your own Python package and publish it on PyPI.  
Read and analyze following steps of publishing package.  
>Think about the job that your package could do!  

Prepare your package in a similar way.  
Make modifications, create newer versions of your package to gain more experience :smiley:


#### **1. Write your Python module and save it under a directory**

#### **2. Create the `setup.py` file with necessary information**

#### **3. Choose a LICENSE and provide a README file for your project**

#### **4. Generate the distribution archives on local machine**

#### **5. Try installing the package on your local machine**

#### **6. Publish the package to the TestPyPi repository to check if all works well**

#### **7. Finally, publish the package to the PyPi repository**