semvec/pypi-packages huggingface dataset:
sql-logger 0.0.2
Log to an SQL database from multiple threads.
License: MIT
Requires Python: >=3.6.0

# README

Log to an SQL database from multiple threads.

This program allows you to log information to different topics stored in a database file, extract subsets based on certain condition, as well as converting such selections into dataframes.

            
## Run instructions
> Note, only tested with Python 3

0. Create an account with Amazon Web Services and create a [MySQL RDS database instance](https://aws.amazon.com/rds/)

1. Clone the repository

       git clone https://github.com/robotpt/sql-logger
    
1. Install the dependencies and setup the project with your Python path

       pip install -e sql-logger

1. Go into the sql-logger
    
       cd sql-logger
       
1. Create a `config.yml` file in the home directory that mirrors the following. 
   If `id` is left blank, then one is assigned based on the next available `id` in the database.

       log_info:
         database_name: my_database
         id: 
       sql_database:
         host: <url>
         password: mysecretpassword
         port: 3306
         user: <user name>
         
1. Tests can be run with the following commands.

       python3 -m unittest
o4 0.5.2
Pipeline for detecting vehicles and pedestrians and extract features.
License: MIT
Keywords: Detection,Tracking,Fingerprint

## Install

`pip install -r requirements.txt`

## Run

`from o4 import O4`

`weights = "tests/wheights/yolov3.weights"`
`names = "tests/wheights/coco.names"`
`anchors = "tests/wheights/yolov3.cfg"`

`INPUT_DIR = "o4/data/input/braga.mp4"`
`OUTPUT_DIR = "o4/data/output/output.avi"`

`o4 = O4(weights, names, anchors)`

`o4.video(INPUT_DIR, OUTPUT_DIR)`

`o4.add_feature(DetectionBoxes())`
`o4.add_feature(Counter(object_types=["person"])`

`while o4.next():`
`  value = counter_persons.get_value()`
`  print(value)`

`o4.close()`
sql-robot-logger 0.1.1
A sql robot logger
License: MIT
Requires Python: >=3.6.0

# README

Creates and updates a robot state logging database.

This program allows you to log information to different topics stored in a database file, extract subsets based on certain condition, as well as converting such selections into pandas dataframes.

## Example 

1. Create a config.yml file in the home directory that mirrors the following

         log_info:
            database_name:
            robot_id: 
         sql_database:
            host: 
            password: 
            port: 
            user:
            
     * if robot_id is left blank, then one is assigned based on the next available robot_id in the database

1. Create the state logger object and give it a unique id and a database to write to (if left blank, one will automatically be created)

             import robot_logger.robot_logger as rl
             robot_logger = rl.RobotLogger()

1. Add a topic and its respective data type
             
            robot_logger.add_topic("test_topic", int)
2. Add integer message with the topic and allow for local backup
            
            robot_logger.write("test_topic", 1234, str(__file__), True)
3. Create the database inspector

            import robot_inspector.robot_inspector as ri
            robot_inspector = ri.SQLInspector()
    
4. Generate a query from the log table that match a custom condition
    
            query = robot_inspector.get_query("log","topic_id = 1")
    
5. Display the list of matches

            print(query)
6. Generate a pandas data frame from the query

            df = q.get()
            
## Run instructions
> Note, only tested with Python 3

0. Clone the repository

       git clone git@github.com:adamhamden/aws-sql-logger-interface.git
       
1. Go in the cloned directory

		cd aws-sql-logger-interface

1. Start a virtual environment

		virtualenv -p python3 venv
		source venv/bin/activate

1. Install the requirements

		pip install -r requirements.txt
		
1. Check that the tests run

		python -m unittest test.py

1. Import and use the module!
pyKirara 1.2.1.post1
a Python wrapper for the starlight.kirara API
License: MIT
Requires Python: >=3.5

[![Documentation Status](https://readthedocs.org/projects/pykirara/badge/?version=latest)](https://pykirara.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/pyKirara.svg)](https://badge.fury.io/py/pyKirara)
# pyKirara

pyKirara is a Python library for the starlight.kirara REST API

[Basic Documentation](https://pykirara.readthedocs.io/en/latest/)

[Async Port](https://github.com/EthanSk13s/async-kirara)
## Usage

```python
import pyKirara

client = pyKirara.Kirara()
uzuki = client.get_idol(101)

print(f"HI! MY NAME IS {uzuki.conventional}")
print("I'll do my best!")
print(f"I'am {uzuki.age} years old!")

# Returns:
# HI! MY NAME IS Shimamura Uzuki
# I'll do my best!
# I'am 17 years old!
```

## Requirements
- Python 3.5+
- [Requests](https://github.com/kennethreitz/requests) library

## License
[MIT](https://choosealicense.com/licenses/mit/)
pylint-starlark 1.1
Run pylint on Starlark files.
License: MIT
Keywords: pylint,starlark,plugin

Use pylint for Starlark files, by doing an AST transform of load() calls into python import statements.

Use it by running `pylint-starlark file.star`, which internally calls `pylint` with the `pylint-starlark-plugin` plugin enabled.
You may also run it `via python3 -m pylint_starlark file.star`.
cottonwood 8
A flexible machine learning framework
License: MIT
Requires Python: >=3.6

# The Cottonwood Machine Learning Framework

Cottonwood is built to as flexible as possible, top to bottom.
It's designed to minimize the iteration time when running experiments
and testing ideas. It's meant to be tweaked. Fork it. Add to it. Customize it
to solve the problem at hand. For more of the thought behind it, read
the post "
[Why another framework?](https://end-to-end-machine-learning.teachable.com/blog/171633/cottonwood-flexible-neural-network-framework)

This code is always evolving. I recommend referencing a specific tag
whenever you use it in a project. Tags are labeled v1, v2, etc. and
the code attached to each one won't change.

If you want to follow along with the construction process for Cottonwood,
you can get a step-by-step walkthrough in End-to-End Machine Learning
[Course 312](https://end-to-end-machine-learning.teachable.com/p/write-a-neural-network-framework/)
and
[Course 313](https://end-to-end-machine-learning.teachable.com/p/advanced-neural-network-methods/)

## Try it out

```bash
python3 -m pip install "cottonwood==8" --user
python3
```
```python3
>>> import cottonwood.demo
```

## Start playing

If you'd like to experiment with ideas of your own, you'll want
to clone the repository to your local machine and install it from there.

```bash
git clone https://github.com/brohrer/cottonwood.git
python3 -m pip install -e cottonwood --user --no-cache
cd cottonwood
git checkout v8
```

## Examples

See what Cottonwood looks like in action.
Feel free to use any of these as a template for a project of your own.
They're MIT licensed.

* [Compress images of the surface of Mars](
  https://github.com/brohrer/cottonwood_martian_images)

## [Revision history](cottonwood/doc/revision_history.md)
bankreader 0.2.3
Romanian banks statement parser
License: MIT

# bankreader

A light bank statement reader/parser. The project is oriented towards Romanian banks statements.
Input for the reader is the `already exported data` from your bank of choice, the library will not support web interaction with bank APIs (if existing). At least not in the foreseeable future.

The project is still new and may suffer API modifications.

Currently there is support only for the *Romanian Raiffeisen .xls statements*.

### Example

```python
from bankreader.romania import RaiffeisenStatement
import os

statement_xls_path = os.path.join('test', 'statements', 'Extras_de_cont_12345678_20012018_31012018.xls')

statement = RaiffeisenStatement(xls_path=statement_xls_path)

print(statement.account_number)
print(statement.client.iban)
print(statement.client.client_address)

for transaction in statement.transactions:
    print(transaction.amount)
    print(transaction.description)
    print(transaction.is_income)
```

Other examples can be seen in the tests.

### Installation

To install/use the module you can:
- download, run `pip install -r requirements` and copy the `bankreader` folder to where you want to user it and simply use such as `from bankreader ...`
- download the project and run `setup.py install`
- install via pip: `pip install bankreader`