semvec/pypi-packages huggingface dataset:
ergo-python-appkit 0.3.2
A python wrapper for the Ergo Appkit

# ergo-python-appkit
This is a wrapper around Ergo's appkit, which is based on scala/java. Jpype is used to map to the JVM and the jar running within. That means that Java needs to be installed for this package to work.

## Installation
Installation can be done through pip. Currently the package is not available yet on PyPi so you need to refer directly to the github.
```
pip install git+https://github.com/ergo-pad/ergo-python-appkit.git
```

## Usage
The ergo appkit can be accessed by importing java classes AFTER importing the appkit, like this:
```python
import ergo_python_appkit.appkit
from org.ergoplatform.appkit import Address

myErgoAddress = Address.create("9gF2wmTWcEX2EZu5QY3dJwURep1HWsXjUZdVavVWESun4Sp8BYj")
#will print the ergotree belonging to the address
print(myErgoAddress.toErgoContract().getErgoTree())
```

There are also convenience methods created to allow for easier use from Python for appkit functionality that is used often.

An example of a simple intra wallet transaction send from the nodes wallet:
```python
from ergo_python_appkit.appkit import ErgoAppKit
from org.ergoplatform.appkit import Address

appKit = ErgoAppKit("http://myergonode:9053","mainnet","http://api.ergoplatform.org","nodeapikey")
myAddress = "9gF2wmTWcEX2EZu5QY3dJwURep1HWsXjUZdVavVWESun4Sp8BYj"

#collect boxes to spend 1 erg
inputs = appKit.boxesToSpend(address=myAddress,nergToSpend=int(1e9))

#Define output box
outputBox = appKit.buildOutBox(
                value=int(1e9),
                tokens=None,
                registers=None,
                contract=appKit.contractFromAddress(myAddress)
            )

#Build the unsigned transaction
unsignedTx = appKit.buildUnsignedTransaction(
                inputs=inputs,
                outputs=[outputBox],
                fee=int(1e6),
                sendChangeTo=Address.create(myAddress).getErgoAddress()
            )

#Sign the transaction with the node
signedTx = appKit.signTransactionWithNode(unsignedTx)

#Send the transaction
appKit.sendTransaction(signedTx)
meduse-CERTIC 0.0.6
Outil en ligne de commande destiné à réaliser des copies statiques des projets du Pôle Document Numérique.
Requires Python: >=3.6

# Meduse

![image de Meduse](https://upload.wikimedia.org/wikipedia/commons/thumb/c/c7/Medusa_Cameo_Petescia_Berlin_Altes_Museum_27042018_2.jpg/231px-Medusa_Cameo_Petescia_Berlin_Altes_Museum_27042018_2.jpg)

Outil en ligne de commande destiné à réaliser des copies statiques des projets du PDN (Pôle Document Numérique).

## Pré-requis

* Python 3.6 ou plus récent
* wget

## Installation hors développement

```
pip install meduse-CERTIC
```

## Principe

3 étapes:

1. Aspiration des sites avec wget.
2. Modification éventuelle des pages.
3. Indexation des pages, dans Elasticsearch si présent.

## Utilisation

Suivre les instructions affichées avec `meduse --help`

## Exemple

Aspirer un site dans le répertoire courant:

```
meduse mirror http://acme.com/
```

Aspirer un site dans un autre répertoire:

```
meduse mirror http://acme.com/ -d /home/johndoe/sites/acme
```

## Installation de l'environnement pour le développement développement

```
$> python3 -m venv venv
$> . ./venv/bin/activate
$> pip install -r requirements.txt
```
cofyflex 0.0.4
COFYCloud Flexibility Microservices
Requires Python: >=3.6

# COFYflex Python

## Description
Python library containing the source code for multiple microservices used by COFYcloud to provide flexibility services.

## Visuals
TODO: Add viz of Price Matrix
See Demo Notebook

## Installation
`python3 -m pip install cofyflex`

## Usage
See Demo Notebooks

## Support
Use the Gitlab issue tracker, or see docs.cofybox.io.

## Roadmap
TODO

## Contributing

- Clone the repo
- Create a virtual environment (`python3 -m venv venv`) & Activate it (`source venv/bin/activate`)
- Install requirements (`pip install -r requirements.txt`)
- Install additional packages for running notebooks and visualisation (`pip install jupyter matplotlib`)
- Start notebook server and run the examples (`jupyter notebook`)

Please contribute by creating a branch per issue and using merge requests that are easily testable.

## Authors and acknowledgment
The DEV-team of the H2020 REScoopVPP project: EnergyID & CarbonCoop

## License
MIT
pyseek 0.1.0
A command line tool for SEC EDGAR data
Requires Python: >=3.9,<4.0

# PySec: a python tool for parsing SEC filing with EDGAR


## Command Line Tool

The CLI interface for pysec will entail the following commands:
1. `pysec init` will start the configuration wizard

    *  this will create a `pysec.json` file in the current directory
    *  accept the user-agent string
    *  accept the save-to folder

2. `pysec get-cik` will get the CIK of the company

    * this will accept the following arguments:
        * `ticker` - the ticker symbol of the company
    * this will return the CIK of the company

3. `pysec company-concepts` will get the company concepts

    * this will accept the following arguments:
        * `cik_number` - the cik_number of the company obtained from `pysec get-cik` command
    * this will return the company concepts

3. `pysec parse` will parse the filing
    * this will accept the following arguments:
        * `ticker` - the ticker symbol of the company
        * `form` - the form type
        * `year` - the year of the filing
        * `quarter` - the quarter of the filing
    * this will parse the filing and save it to the `save_to` folder

## Testing



tesla_forms.json file contains the sample response of the tesla ticker


# to do

1. set up configuration file
    * need user agent
    * need `save_to` folder
    *
zetl-package 0.0.1
A simple ETL framework for Python, SQL and BAT files which uses a Postgres database for activity logging.
Requires Python: >=3.7

A simple ETL framework for Python, SQL and BAT files which uses a Postgres database for activity logging.
the zetl framework requires python and Postgres to run.

---

### 1. Install Python

Download and install python (https://www.python.org/downloads/) to your local computer.

### 2. Install Postgres

Download and install postgres (https://www.postgresql.org/download/) to your local computer.  Remember the password.  After installing Postgres, your connection string will be:

> - host: localhost
> - port: 1532
> - name: postgres
> - schema: public
> - Username: postgres  
> - Password: <whatever_you_supplied>

### 3.Install zetl on Local windows pc 

download zetl (https://github.com/daveskura/zetl/archive/refs/heads/main.zip) and unzip to a local folder on your computer, such as c:\zetl
  
Folder will look like this:
  
> - zetl
> - zetl\examples
> - zetl\install_ddl
> - zetl\zetl_scripts

### 3. Run setup.bat
  
This will install the neccessary python packages and prompt for connection details to the Postgres database you just istalled. Hit enter to accept the defaults and enter the password you entered during the database setup.
  
setup will then connect to postgres and create the 3 tables required by zetl.
> - z_activity
> - z_log
> - z_etl
 
### 4. Run zetl.py
  
To run any zetl commands, go to the command line and change to the zetl directory.  eg. CD \zetl

If your setup is successful, when you run zetl.py with no parameters, it will connect and list ETL's available to run such as:
  
> - demo1
> - demo2
> - demo3
> - view_log
> - empty_log

--- 

### Usage

--- 

### What is an ETL in the zetl framework ?

An ETL exists in the form of a directory, under zetl_scripts, with files of a specific naming convention which are either python, windows bat, or sql.  The file naming convention is as follows: step_number.activity.extension
  
> - **step_number** is any integer unique in the immediate folder
> - **activity** is any alphanumeric name for the activity of the file
> - **extension** must be either py, bat or sql

####  For example:
  
> - zetl\zetl_scripts\demo1\1.hello.py
> - zetl\zetl_scripts\demo1\2.something.sql
> - zetl\zetl_scripts\demo1\3.hello.bat

### create an ETL

create a folder under zetl_scripts and add a file which follows the naming convention step_number.activity.extension
For example:

- 1.anything.sql
- 2.anythingelses.bat
- 3.something.py

### run an ETL

Go to the command line and change to the zetl directory.  eg. CD \zetl
pass the ETL as a parameter to zetl

for example:

> zetl demo1

### View the ETL Log

Everytime an ETL runs, the z_log table is updated with the activity.  To see view the log, query the z_log table or run the ETL view_log as follows:

> zetl view_log
cgmhc 0.1.1
Tools for finding MHC alleles for WGS/RNAseq samples
Requires Python: >=3.9

# cgmhc

A set of tools that are useful for finding the MHC/HLA alleles for a given
sample using WGS, WES, or RNAseq data. In particular, these tools are designed for
the identification of MHC alleles to use in identification of novel peptides that can
be presented by MHC Class I proteins for finding presented neoepitopes in cancer.
As such, the specificity of the results are designed only for this purpose.

These tools implement a particular workflow that assumes you have the following:

    bwa
    samtools
    ngsutilsj

Additionally, the tools are built to work with data from the IPD-IMGT/HLA database
which is available from: https://hla.alleles.org

Finally, final prediction can use MHC peptide binding affinities from mhcFlurry which
are available here: https://openvax.github.io/mhcflurry-motifs/mhcflurry.allele_sequences.csv

The basic workflow can be described as:

## WGS
1) Find the location of HLA alleles in the reference genome.
2) Extract flanking sequence from the reference genome, and adding this sequence
   to the allele sequences
3) Extraction of mapped reads to the HLA locus in an already aligned BAM file
4) Re-alignment of these reads (optionally with unmapped reads as well) to the 
   now extended flanking HLA allele sequences
5) Score HLA allele pairs (maternal/paternal) to find the most likely genotypes
   for the individual.
6) Predict the most likely genotypes

## RNAseq
The RNAseq/WES workflow is similar, but instead of using the `*_gen.fasta` versions
of the IPD-IMGTR/HLA sequences you can use the `*_nuc.fasta` versions. When using these
coding mRNA sequence, you can skip steps 1 and 2. And instead of extracting a sub-set
of reads, you can align the raw FASTQ sequence. The scoring and prediction steps remain
the same.