semvec/pypi-packages huggingface dataset:
miniMinio 2.6.0
Exposing file sharing system
Requires Python: >=3.6.1

# miniMinio

A thin python helper get either 1) local files or 2) Minio objects. 1) Heavily relies on the default os library while 2) is built off [minio-py](https://github.com/minio/minio-py). The package is designed to provide a seamless switch between testing file operations locally/over a file system and interacting with a minio server when in deployment.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install miniMinio.

```bash
pip install miniMinio
```

## Quick Start

```python
from miniMinio import Minio

# For connecting to minio s3
mc = Minio(type="minio").config(hostname='host',
                                access_key='minio',
                                secret_key='minio',
                                secure=False
                                )
mc.ls('bucket/dir/')

# For connecting to local filesystem
mc = Minio(type="local").config()
mc.ls('.')
```


## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)
ofunctions.delayed-keyboardinterrupt 0.1.0
Intercept CTRL+C signal in your Python code
Requires Python: >=3.5
Keywords: network,bisection,logging

# ofunctions
## Collection of useful python functions

[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![Percentage of issues still open](http://isitmaintained.com/badge/open/netinvent/ofunctions.svg)](http://isitmaintained.com/project/netinvent/ofunctions "Percentage of issues still open")
![Linux Build Status](https://github.com/netinvent/ofunctions/workflows/ofunctions-linux-tests/badge.svg)
[![GitHub Release](https://img.shields.io/github/release/netinvent/ofunctions.svg?label=Latest)](https://github.com/netinvent/ofunctions/releases/latest)

ofunctions is a set of various recurrent functions amongst

- bisection: bisection algorithm for *any* function with *any* number of arguments, works LtoR and RtoL
- checksums: various SHA256 tools for checking and creating checksum files
- delayed_keyboardinterrupt: Just a nifty tool to catch CTRL+C signals
- file_utils:
- json_sanitize: make sure json does not contain unsupported chars, yes I look at you Windows eventlog
- logger_utils: basic no brain console + file log creation
- mailer: send emails regardless of ssl/tls protocols, in batch or as single mail, with attachments
- network: various tools like ping, internet check, MTU probing and public IP discovery
- platform: nothing special here, just check what arch we are running on
- process: simple kill-them-all function to terminate subprocesses
- pw_gen: basic password generator
- service_control: control Windows / Linux service start / stop / status
- string_handling: Remove accents / special chars from strings

## Setup

```
pip install ofunctions.<subpackage>

```
asen-6008 2.0.0
Constants for CU Boulder's ASEN 6008
Requires Python: >=3.6

## About

This library encodes all of the information provided in the handouts Coefficient Data and Ephemeris_Meeus from ASEN 6008 (CU Boudler). This library was created in Spring 2021 when the course was taught by Professor Kate Davis.

## Installation

```
pip install asen_6008
```

## API

This library provides 10 classes (the 8 planets, Pluto, and the Sun) and 2 constants, AU and Days_per_year.

The classes are all instances of the class Planet which has the following layout (note this is pseudocode)

```
class Planet:
	L # deg
    a # AU
    e
    i #deg
    Omega # deg
    Pi  # deg
    mu  # km3/s2
    r # km
```

Elements L, a, e, i, Omega, and Pi are of type OrbitalElement which has the following layout
```
class OrbitalElement:
	a0
	a1
	a2
	a3
```

Elements mu and r are simply floating point values.

To access any of the data for a planet would look something like this

```
import asen_6008

print(asen_6008.Mars.L)
print(asen_6008.Earth.e.a1)
print(asen_6008.Sun.mu)
```

The names of all the classes and constants provided are listed below

```
AU
Days_per_year
Sun
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune
Pluto
```

Also, both the Planet and OrbitalElement class have overridden the `__repr__` class attribute, so they can be printed directly, for example:

```
>>> import asen_6008
>>> print(asen_6008.Jupiter)
L (deg): 34.351484, 3034.9056746, -8.501e-05, 4e-09
a (AU): 5.202603191, 1.913e-07, 0, 0
e: 0.04849485, 0.000163244, -4.719e-07, -1.97e-09
i (deg): 1.30327, -0.0019872, 3.318e-05, 9.2e-08
Ω (deg): 100.464441, 0.1766828, 0.00090387, -7.032e-06
Π (deg): 14.331309, 0.2155525, 0.00072252, -4.59e-06
μ (km3/s2): 126686536.1
r (km): 71492
```


## Usage

Because the professor requested that no equations be placed in the library, only constants, the user will have to supply their own equations for calculating the ephemeris information as a function of time. There are many ways to do this, but one way which leads to a fairly clean API is to wrap the classes provided in your own class, like this

```
import asen_6008

class MyPlanet():
	def __init__(self, planet):
		self.planet = planet

	def e(self, t):
		return self.planet.e.a0 + self.planet.e.a1 * t + self.planet.e.a2 * t**2 + self.planet.e.a3 * t**3

Earth = MyPlanet(asen_6008.Earth)
Mars = MyPlanet(asen_6008.Mars)

print(Mars.e(some_julian_date))
```

You'll want to put this class and the instance of it in a separate file that you then import into your main Python project.

This way you can access various properties of the planet with a simple interface that accepts a time value. But you can also reach in directly to the underlying class provided by the asen_6008 library, as follows:

```
print(Earth.planet.e) # Here Earth is the same instance that was defined above.
```
igblast-parser 0.0.4
Parser of Igblast results into a csv file
Requires Python: >=3.6

## Simple parser of igblast results

[Igblast](https://github.com/ncbi/igblast) allows to view the matches to the germline V, D and J genes, details at rearrangement junctions and a lot more (see [documentation](https://ncbi.github.io/igblast/)).  

The output includes a lot of information in a format that can't be directly used in statistical analyses.  

This simple script parses igblast output into a csv formatted table, easy to understand and ready to include in a statistical analysis.


### Installation

1. pip install igblast-parser  
2. conda install -c bioconda igblast-parser   

3. python setup.py install

### Usage

docs

While docs are not ready:

Command line executable in unix-like systems:
```bash
	cat <igblast.output> | igblast-parser
``` 
Pipe is not obligatory as the input could be specified with the argument `--in`   

optional argument: `--out` to specify the prefix of the output csv file   
```bash
	igblast-parser --in <igblast.output> --out <parser_output>
```

In interactive python or script
```python
	f_in = open('igblast.output','r')

	# dictionary with UMI as primary key and multiple keys/UMI
	d = igblast_parse(f)

	# pandas provides very nice tables
 	import pandas
	df = pandas.DataFrame(d).T
```