semvec/pypi-packages huggingface dataset:
ottoai 0.0.5
The most minimalistic library for building intelligent AI Agents straight from Python Objects

<img src="https://github.com/mindsdb/otto/assets/5898506/c1205022-7f73-41cc-82ea-8075801bdbd4" alt="description" style="width: 20%;" />


# Otto: The minimalistic Framework to build AI Assistants 


Welcome to Otto, the most minimalistic library for building intelligent AI Assistants, adept for also handling multitenancy and secure authentication.

```
pip install ottoai
```


## Example

Turn the Github SDK into an agent that can answer questions from Github live data using pandas to calculate results.

```Python
import ottoai
import openai
import pandas

from github import Github, Auth


# create an assistant
eve = ottoai.Assistant(name="eve", personality="Like Scarlett Johansson with John Oliver's wits", llm_engine=openai, model="gpt-4")

# Make your agent capable of answering questions and do all things Github, by simply passing the sdk module
# Remember. Just pass objects as skills, and Otto will figure out the rest. 
eve.add_skill(Github)
eve.add_skill(pandas)

# Start a conversation and add user specific context (variable names must be interpretable, Otto will take care of the rest)
# In this case the assistant will need access token to github, this is so you can pass context dynamically (solving for multitenancy)
conversation = eve.start_conversation(user_name = "Bob", user_context_variables = {"github_api_token":"sometoken"} ) 

# ask a question
response = conversation.message("Who were the last 5 people to star the mindsdb/otto repo?")

```

As simple as that, no need to build tools or chaining, just pass objects as skills, otto figures out the rest.
browserpedals 0.0.7
Control videos in web browser with pedals
Requires Python: >=3.6
Keywords: browser foot pedals video audio transcribing pause play typing subtitles selenium webdriver


Control any video or audio in a web browser with foot pedals (pause/play or jump back),
even when the web browser is not in focus (for example, while typing in text editor).

| This may be helpful during transcribing (listening to a video and typing the spoken text).
| The program will attempt to recognize new foot pedals automatically.
| There is an option to create subtitles: After every Play and Pause using pedals,
| SRT subtitle timing for the played video fragment is copied to clipboard and can be pasted
| into any text file before corresponding text fragment to make it an SRT subtitle.
| There is an option to periodically pause a video and copy timestamps to clipboard.
| (Under the hood, the program uses Selenium project to control the browser.)

To install the program on Linux, open command line and type::

$ python3 -m pip install --no-cache-dir browserpedals

To use subtitles option on Linux, additionally install xclip::

$ sudo apt-get install xclip

To install the program on Windows, open command line or Windows PowerShell and type::

$ py -m pip install --no-cache-dir browserpedals

During the installation, ``BrowserPedals`` icon will be created on the Desktop.
To run the program, double-click on this icon and wait for new browser window to open.
In the browser, home page will open with information about the program and
a pop-up dialog for detecting and testing the pedals.
detectorusoutlierus 0.0.1b0
Small package created for detecting outliers
Requires Python: >=3.7

<h1>detectorusoutlierus</h1>

<h4>Small package created for detecting outliers.</h4>

**Usage:**
* *<h5>install the package: from detectorusoutlierus import outliers as do</h5>*
* *"detect_outlier_mean_std"* - by mean and standard deviation. Takes column as a parameter
* *"detect_outlier_kvart"* - by kvartile. Takes column as a parameter
* *"detect_outlier_dbscan"* - with DBSCAN (clusterization). Takes two columns as a parameters
* *"detect_outlier_shovene"* - by Shovene method. Takes column as a parameter

**Example:**

from detectorusoutlierus import outliers as do

outlier_detector = do.Outline(df)

outliers_mean = outlier_detector.detect_outlier_mean_std('column_name')

outliers_mean
python-dhl-germany 0.3.4.14
Python Lib for DHL SOAP API (Germany)
Requires Python: >=3.9
Keywords: DHL,Python

# python_dhl_germany

# New WSDL version
- Got to DHL Geschaeftskundenversand and download the zip:
https://entwickler.dhl.de/group/ep/wsapis/geschaeftskundenversand/current

- Create a new wsdl folder
- rename geschaeftskundenversand-api-x.x.x-wsdl to production.wsdl
- copy production.wsdl to test.wsdl
- open test.wsdl and patch
  - FROM: <soap:address location="https://cig.dhl.de/services/production/soap"/>
  - TO: <soap:address location="https://cig.dhl.de/services/sandbox/soap"/>
- set new version in setup.py -> data_files (array)

## install dev
- create venv: python -m venv venv
- activate venv:
  - Windows: venv/Scripts/activate
  - Linux / Mac: source venv/bin/activate
- pip install -r requirements.txt -r requirements_dev.txt
- pre-commit hook install: pre-commit install --hook-type pre-push
- create .env file and add DHL_AUTH_USER + DHL_AUTH_PASSWORD variables

## build and deploy
- python setup.py sdist bdist_wheel
- s3pypi --bucket pypi.fourzero.one

# usage

create dhl client:
```
dhl_client = DHL(
    "DHL_AUTH_USER", # test: DHL-Entwickler User / live: DHL App Name
    "DHL_AUTH_PASSWORD", # test: DHL-Entwickler PW / live: DHL App Token
    "API_USER", # test: 2222222222_01 / live: Geschäftskunden-Portal system user name
    "API_PASSWORD", # test: pass / live: Geschäftskunden-Portal system user pw
    is_test=True,
)
```

create shipment order:
```
shipper = {
    "name": "Something Something GmbH",
    "name2": "",
    "street": "Teststraße",
    "street_number": "32",
    "zip": "22222",
    "city": "Bremen",
    "country_code": "DE",
    "phone": "040251090",
    "email": "test@test.com",
    "contact_person": "Test User",
}

receiver = {
    "name": "Test Tester",
    "name2": "TestCompany",
    "street": "Teststraße",
    "street_number": "12",
    "zip": "28217",
    "city": "Bremen",
    "country_code": "DE",
    "careOfName": "",
}

order = {
    "customs": {
        "invoice_no": "1234567",
        "description": "Ziegelsteine",
        "place_of_commital": shipper["city"],
    },
    "positions": [
        {
            "name": "Test Product 1",
            "amount": 2,
            "price": 12.5,
            "weight": 0.15,
            "customs": {
                "country_code_origin": "DE",
                "customs_tariff_number": "49119900",
            },
        },
        {
            "name": "Test Product 2",
            "amount": 3,
            "price": 1.5,
            "weight": 100,
            "customs": {
                "country_code_origin": "DE",
                "customs_tariff_number": "49119900",
            },
        },
    ],
}

dhl_client.create_shipment_order(
    "ORDER_ID",
    shipper, # find example in integration test
    receiver, # find example in integration test
    6.0, # weight
    "V01PAK", # dhl product
    "22222222220101", # dhl account number
    order_to_ship=order, # find example in integration test
)
```
detectorus-outlierus 1.0
Small package created for detecting outliers.
Requires Python: >=3.7
Keywords: example python

<h1>outlierus_detectorus</h1>

<h4>Small package for detecting outliers</h4>

**Usage:**
* *<h5>install the package</h5>*
* *"detect_outlier_mean_std"* - by mean and standard deviation. Takes column as a parameter
* *"detect_outlier_kvart"* - by kvartile. Takes column as a parameter
* *"detect_outlier_dbscan"* - with DBSCAN (clusterization). Takes two columns as a parameters
* *"detect_outlier_shovene"* - by Shovene method. Takes column as a parameter
gdshechka 2.3
https://sites.google.com/view/n1c1n1/programs/gdshechka-doc
Requires Python: >=3.11,<4.0

Geometry Dash in python

2.3 Update:
 - Сode descriptions
 -requirements

DOC: https://sites.google.com/view/n1c1n1/programs/gdshechka-doc
dacwinapi 2.2.0
This package makes it easy to manage information about your DacWin referral system.
Requires Python: >=3.9

# DacWin API

The Python package dacwinapi makes it easy to manage information about your DacWin referral system. This package is specifically designed to interact with the DacWin API and allows you to manage information about an application's users, referral campaigns, rewards and events.

DacWin home page: https://referral-dev.dactechnologies.net

## Installation

To install `dacwinapi`, you can use pip:

```bash
pip install dacwinapi
```

Before using this package you must have the API key of the application you want to manage. If this is not the case yet,
- Go to your customer area: https://referral-devuser.dactechnologies.net
- In the `Applications` section:
	- Add an application and copy the generated API key.
	- Or, open your application's edit window and **regenerate a new API key** if you no longer have the old one.

## How to use this package

### 1. Campaigns

```python
from dacwinapi import CampaignService

# create an instance of CampaignService
campaignService = CampaignService(api_key="your_app_api_key")

# retrieve the list of campaigns of the app
campaigns = campaignService.getAll()

# retrieve one campaign data
campaigns = campaignService.getOne(1) # 1 is the campaign id 
```

> NOTE: Creating a campaign is only done on your DacWin customer interface.

### 2. App users

```python
from dacwinapi import AppUserService

# create an instance of AppUserService
appUserService = AppUserService(api_key="your_app_api_key")

# add new app user with referral information
app_user_created = await appUserService.create(
	reference="3ddd",
	referrer_referral_code="AAAAA"
)

print(app_user_created)

# retrieve the list of app users of the app
app_users = appUserService.getAll()

# retieve one app user by her id
app_user = appUserService.getOne(id=1) # 2 is the app user id

# retieve one app user by her reference
app_user = appUserService.getOne(reference="a2sddd") # "a2sddd" is the app user reference
```

### 3. Events

```python
from dacwinapi import EventService

# create an instance of EventService
eventService = EventService(api_key="your_app_api_key")

# add a new event for specific app user and campaign
event_created = eventService.create(
	name="ddd",
	campaign_id=18,
	app_user_id=14
)

print(event_created)

# retrieve the list of events of the app
events = eventService.getAll()

# retrieve the list of app's events of specific campaign
events = eventService.getAll(campaign_id=12)

# retrieve one event
event = eventService.getOne(12) # 12 is the event id

```

### 4. Rewards

```python
from dacwinapi import RewardService

# create an instance of RewardService
rewardService = RewardService(api_key="your_app_api_key")

# retrieve the list of rewards of the app
rewards = rewardService.getAll()

# retrieve the list of app's rewards of specific campaign
rewards = rewardService.getAll(campaign_id=12)

# retrieve one reward
reward = rewardService.getOne(id=12)
```
outlierus-detectorus-ugumus 1.0.2
Small package created for detecting outliers.
Requires Python: >=3.7
Keywords: example python

<h1>outlierus_detectorus</h1>

<h4>Small package for detecting outliers</h4>

**Usage:**
* *<h5>install the package</h5>*
* *"detect_outlier_mean_std"* - by mean and standard deviation. Takes column as a parameter
* *"detect_outlier_kvart"* - by kvartile. Takes column as a parameter
* *"detect_outlier_dbscan"* - with DBSCAN (clusterization). Takes two columns as a parameters
* *"detect_outlier_shovene"* - by Shovene method. Takes column as a parameter
outlierus-detectorus 1.0.1
Small package for detecting outliers
Requires Python: >=3.7
Keywords: example python

<h1>outlier_detector</h1>

<h4>Small package for detecting outliers</h4>

**Usage:**
* *<h5>install the package</h5>*
* *"detect_outlier_mean_std"* - by mean and standard deviation. Takes column as a parameter
* *"detect_outlier_kvart"* - by kvartile. Takes column as a parameter
* *"detect_outlier_dbscan"* - with DBSCAN (clusterization). Takes two columns as a parameters
* *"detect_outlier_shovene"* - by Shovene method. Takes column as a parameter
sympy-air-dynamics 0.0.1
air_vapour_pressure_dynamics: Repository with the basic functions related with the temperature, relative humidity, absolute humidity and entalpy of the air with the different variable transformations
Requires Python: >=3.10

# AIr Vapour Pressure Dynamics

Repository with the basic functions related with the temperature, relative humidity, absolute humidity and entalpy of the air with the different variable transformations

## How it work:

1. Create en python environent and install the package using de command:
    ````
    pip install air_vapour_pressure_dynamics
    ````
2. Once you get installed the package you can import the packahe in the python module by:
    ````
    from air_vapour_pressure_dynamics import vapourpressure, absolutehumidity_kg_air,....
    ````
    or 

    ````
    import air_vapour_pressure_dynamics
    ````
and that's it!!