semvec/pypi-packages huggingface dataset:
gcloud-functions-params 0.0.2
package for manage params in python gcloud functions

# Gcloud functions params

package for manage params in python gcloud functions

## Install
```requirements.txt
gcloud-functions-params==0.0.2
```

## Http function

You can call the function sending arguments:

http://function-url?name=example

or sending json

```
curl http://function-url -H "Content-Type: application/json" -d '{"name": "example"}'
```

```python
from gcloud_functions_params import args_or_json_to_dict

def main(request):
  params = args_or_json_to_dict(request)
```

## Pubsub function

you can send a json in the event message

message: '{"name": "example"}'

```python
from gcloud_functions_params import event_to_dict

def main(event, context):
  params = event_to_dict(event)
```
invade 0.0.6
A library for interacting with Windows process memory
Requires Python: >=3.6

# Invade

![Invade](https://i.imgur.com/nGSXlnr.jpg "Invade")

Invade is a Python 3 library for interacting with Windows processes. Common uses: software security and malware research, reverse engineering, and PoCs.

[https://github.com/cgio/invade](https://github.com/cgio/invade)

[https://pypi.org/project/invade](https://pypi.org/project/invade)


**There are four classes in main.py:**

* **Me:** for operating environment info
* **Scout:** for process discovery
* **Target:** for target process info
* **Tool:** for main operation

**Common use case overview:**

1. Create an instance of Me and check the operating environment for compatibility.
2. Use Scout to get a list of active processes and the desired PID (process identifier).
3. Instantiate Target using the PID obtained by Scout.
4. Check Target instance properties for information about the target process.
5. Interact with the target process using Tool methods.

Another common use case is Invade's relatively fast byte pattern search with wildcard support. Operation is similar to [IDA's](https://www.hex-rays.com) "sequence of bytes" search. Use Tool.search_file_pattern() to search through a file on disk.

Tool.memory_read_pointers() is also useful. With it, you can read through a series of dynamically allocated memory pointers in another process. The method accepts a string containing a start address and relative pointers with common arithmetic operators.

**Refer to main.py for additional information and usage instructions.**

**Refer to RELEASE.md for release notes.**

## Installation
Python 3.6+ is required

`pip install invade`

Install Keystone for Python. See [Python module for Windows - Binaries](http://www.keystone-engine.org/download/).

Install Capstone for Python. See [Python module for Windows - Binaries](https://www.capstone-engine.org/download.html).

## Files
Inside /invade:
* **main.py:** contains all main code and classes
* **winapi.py:** contains Windows API code
* **version.py:** contains version information

## Example Projects
* [invade_debug_32](https://github.com/cgio/invade_debug_32): Windows x86 32-bit non-attaching debug tool
* [invade_keepass](https://github.com/cgio/invade_keepass): KeePass password exfiltration

## Authors
Chad Gosselin ([https://github.com/cgio](https://github.com/cgio))

## Credits
Thank you to the following projects:

* [Keystone](https://github.com/keystone-engine/keystone): assembler framework
* [Capstone](https://github.com/aquynh/capstone): disassembler framework
* [Cuckoo Sandbox](https://github.com/cuckoosandbox/cuckoo): malware analysis framework
* [pefile](https://github.com/erocarrera/pefile): PE file framework

## License
This project is licensed under the MIT License. See [LICENSE.md](LICENSE.md) for details. This project is for educational purposes only. Use at your own risk.
strainpycon 1.0
Strain disambiguation methods for mixed DNA samples

# Introduction

StrainPycon is a Python 3 package that can be used to disambiguate multiple
strains in mixed samples of DNA. Mathematically, StrainPycon can solve binary
blind source separation problems and compute certain high-dimensional integrals
involving binary variables. The connection between these mathematical concepts
and strain identification is discussed in the following journal article:  

  L. Mustonen, X. Gao, A. Santana, R.M. Mitchell, Y. Vigfusson, and L. Ruthotto,  
  A Bayesian framework for molecular strain identification from mixed diagnostic samples,  
  *Inverse Problems* 34(10), 105009, 2018,  
  https://doi.org/10.1088/1361-6420/aad7cd

StrainPycon builds on the StrainRecon.jl package written in Julia:
https://github.com/lruthotto/StrainRecon.jl

# Motivation

As a motivating example, suppose you have a blood sample infected by multiple
Plasmodium falciparum malaria parasites. Assuming you have done PCR on chosen
SNP sites, the number of calls that differ from the reference genome are
indicative of what proportion of the strains have mutated at that SNP.
StrainPycon is an approach for identifying the strains in the sample through
disambiguation (deconvolution) without requiring any prior knowledge about the
sample or the parasite. The process can also help assess the multiplicity of
infection in the sample, which can aid malaria surveillance efforts, for
instance.

# Citation

If you use StrainPycon in your project, please cite the journal article above.

# Full documentation

Please refer to the full documentation of StrainPycon at:
https://www.ymsir.com/strainpycon/

# Requirements

StrainPycon was tested in the following environment:
+ 64-bit Linux
+ Python 3.6.5 with NumPy 1.14.3

# Basic usage

Usually, the user only wants to access a few methods from the StrainRecon class:

``` py
import strainpycon
S = strainpycon.StrainRecon()
```

Let us generate synthetic measurement data with three strains and 24 SNP sites
and solve the inverse problem:
``` py
(measurements, strains, freq) = S.random_data(24, 3)
(strains_recon, freq_recon) = S.compute(measurements, 3)
```
Here, `strains_recon` should equal `strains` and `freq_recon` should equal
`freq`.

Next, let us draw another random measurement, now with Gaussian additive noise.
We compute the *misfit*, or negative log-likelihood, when the number of strains
in the reconstruction varies from one to seven. Moreover, we compute posterior
statistics to quantify uncertainty:
``` py
gamma = 0.1 # standard deviation of Gaussian noise
(measurements, strains, freq) = S.random_data(18, 4, gamma=gamma)
misfits = S.misfits(measurements, range(1,8))
(strains_mean, freq_mean, strains_dev, freq_dev) = S.posterior_stats(measurements, 4, gamma)
```

A complete description of the methods and detailed examples can be found on:
See https://www.ymsir.com/strainpycon/

# Known issues

StrainPycon does not support multi-threading yet.

# Contacts

Please direct questions to:
Ymir Vigfusson, Emory University, ymir.vigfusson@emory.edu
MongoRandomizer 0.3.11
A small and basic package to create randomized MongoDB documents and trivial load.

# MongoDataRandomizer

This is a simple data randoizer to load up a MongoDB database with data.

## Installation
### From PyPI
* `pip install MongoRandomizer`

### From Source
* Download source code
* `cd` to the download directory
* Run `pip install --editable .`

## Use
### Help
```
graboskycMBP:~ graboskyc$ MongoRandomizer -h
usage: MongoRandomizer [-h] [-c CS] [-t T] [-b B] [-m M] [-p P] [-w WC] [-j]
                       [-g]
                       task

CLI Tool for continually writing random data to a MongoDB database for testing
purposes

positional arguments:
  task              clean, insert, insertAndUpdate, read, everything

optional arguments:
  -h, --help        show this help message and exit
  -c CS             server connection string
  -t T              threads to use, if left off, use 10
  -b B              blocksize to use. if not inclided, use 1000
  -m M              max blocks to use. if not inclided, use 1000
  -p P              additional chars of padding to increase document size
  -w WC             write concern to use. if blank, none used
  -j, --journaling  if omitted, false. if flag enabled, journal
  -g, --geo         if omitted, use customer data. if flag enabled push
                    geographic data
  ```

### Random Inserts

```
graboskycMBP:~ graboskyc$ MongoRandomizer -c mongodb://localhost -t 5 -b 500 -p 10 -w 1 -j insert

About to enter data in: 
	Threads: 5
	DB: demodb
	Collection: democollection
	Blocksize: 1000
	Max Blocks: 500
	Write Concern: 1
	Journaling: True

This process will continue until you press control+c or break
```

### Sample Document
```
{
	"_id" : ObjectId("5b7db58ecc39345cebc78f67"),
	"prescriptions" : [
		"Drug water adult.",
		"Enjoy month.",
		"Just always wind summer.",
		"Bad street me.",
		"Assume.",
		"Section.",
		"Forward nearly.",
		"Town community boy.",
		"Vote major.",
		"Walk.",
		"Left night receive.",
		"Relationship speak.",
		"Affect nearly.",
		"Present star special.",
		"Employee instead.",
		"Kid foot direction poor.",
		"Determine law."
	],
	"accountNumber" : 48,
	"padding" : "aaaaaaaaaa",
	"address" : "847 Ferguson Rd.",
	"payment" : 60,
	"occupation" : "Aid worker",
	"singupDate" : ISODate("2018-08-22T19:11:55.442Z"),
	"copay" : 20,
	"notes" : "Crime evening nation artist blue far fast generation. Play list range none before night everyone. Doctor make score around.",
	"zipcode" : "43418",
	"state" : "WY",
	"fullname" : "Donna Webster",
	"deductible" : 300
}
```

### Sample Geo Document
```
{
	"_id" : ObjectId("5b9fd129cc39341758236d80"),
	"padding" : "",
	"notes" : "Wait mean performance view billion plan civil this. Cup prevent season.\nEffect thought while get market war wife oil.",
	"name" : "Mr. Antonio Salas MD",
	"location" : {
		"type" : "Point",
		"coordinates" : [
			-73.59354663520122,
			42.00216814289992
		]
	}
}
```
mini-patch 1.0.0
Tiny diffs using difflib's SequenceMatcher

Do you have textual (or binary) data that you need to patch?

```
>>> a = 'you say yes, i say no'
>>> b = 'you say stop, and i say go go go'
```

But you want a smaller patchfile than what difflib's `unified_diff()` creates?

```
>>> diff = '\n'.join(difflib.unified_diff(a, b))
>>> len(diff)
137
```

`mini_patch` also uses difflib's `SequenceMatcher` machinery, but it creates
tiny, ASCII-encoded patches:

```
>>> patch = mini_patch.make_mini_patch(a.encode('utf-8'), b.encode('utf-8'))
>>> patch
'0!d:8,2;i:11,$4$dG9w;i:12,$8$IGFuZA==;r:19,1,$4$Zw==;i:21,$8$IGdvIGdv;'
>>> len(patch)
70
```
releasy-uff 1.0.3
Releasy is a tool that collects provenance data from releases by parsing the software version control and issue tracking systems.

Releasy
=======

Releasy is a tool that collects provenance data from releases 
by parsing the software version control and issue tracking
systems.

Papers
======

[Curty, F., Kohwalter, T., Braganholo, V., Murta, L., 2018. An Infrastructure for Software Release Analysis through Provenance Graphs. Presented at the VI Workshop on Software Visualization, Evolution and Maintenance.](https://goo.gl/9u8rzc)

How to use
==========

Basic Usage
-----------

```
$ python -m releasy [release-name] <command> [options]
```

**E.g.:**

Show information about the release 1.0.0
```
$ python -m releasy project download https://api.github.com/repos/gems-uff/releasy/issues
$ python -m releasy 1.0.0 show
```

Installation
------------

```
pip install releasy-uff
```

Available Commands
------------------

Show project information
```
$ python -m releasy project overview
```

Download project issues
```
$ python -m releasy project download https://api.github.com/repos/gems-uff/releasy/issues
```

Show release information
```
$ python -m releasy 1.0.0 show
```

Export prov-n from a release
```
$ python -m releasy 1.0.0 prov
```