semvec/pypi-packages huggingface dataset:
itaxotools-pygblocks 0.1.0
Python implementation for Gblocks
Requires Python: <4,>=3.11

# PyGblocks

[![PyPI - Version](https://img.shields.io/pypi/v/itaxotools-pygblocks)](
    https://pypi.org/project/itaxotools-pygblocks)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/itaxotools-pygblocks)](
    https://pypi.org/project/itaxotools-pygblocks)
[![GitHub - Tests](https://img.shields.io/github/actions/workflow/status/iTaxoTools/pygblocks/test.yml?label=tests)](
    https://github.com/iTaxoTools/pygblocks/actions/workflows/test.yml)

Pure Python implementation for the algorithm behind Gblocks.

## Differences

- Can define which characters are considered as gaps
- Any character that is not defined as a gap is considered for conservation
- Can define how many gaps are allowed per position (number or percentage)
- Positions that only contain gaps are not pre-emptively removed
- Conservation threshold may be set below 50%
- No support for similarity matrices

## Installation

PyGblocks is available on PyPI. You can install it through `pip`:

```
pip install itaxotools-pygblocks
```

## Usage

First create a mask from your sequences, then apply that mask to each sequence:

```
from itaxotools.pygblocks import compute_mask, trim_sequences

sequences = [
    "--TTTNNTACTTTTTTT-ATT",
    "--TTTNTTACGTTTTTG-ATT",
    "--TTTNTTAGTTTTTTC-ATT",
]

mask = compute_mask(sequences)
trimmed_sequences = trim_sequences(sequences, mask)
```

You may customize the trimming parameters and enable logging
when creating the mask:

```
from itaxotools.pygblocks import Options, compute_mask

options = Options(
    IS=2,    # Minimum Number Of Sequences For A Conserved Position
    FS=3,    # Minimum Number Of Sequences For A Flank Position
    CP=2,    # Maximum Number Of Contiguous Nonconserved Positions
    BL1=3,   # Minimum Length Of A Block, 1st iteration
    BL2=3,   # Minimum Length Of A Block, 2nd iteration
    GT=2,    # Maximum Number of Allowed Gaps For Any Position
    GC="-",  # Definition of Gap Characters
)

mask = compute_mask(sequences, options, log=True)
```

You may optionally set IS, FS and GT as a percentage of the number of sequences
by setting IS, FS and GT values to zero, then modifying the percentage
defaults if desired:

```
options = Options(
    IS=0, FS=0, CP=2, BL1=3, BL2=3, GT=0, GC="-",

    IS_percent = 0.50
    FS_percent = 0.85
    GT_percent = 0.00
)

mask = compute_mask(sequences, options, log=True)
```

You may find the above examples, plus some examples on how to use PyGblocks
with BioPython alignments, in the [scripts](scripts) folder.

# Citations

Castresana J. Selection of conserved blocks from multiple alignments for their use in phylogenetic analysis.
Mol Biol Evol. 2000 Apr;17(4):540-52. doi: 10.1093/oxfordjournals.molbev.a026334. PMID: 10742046.
Skull 0.0.3
memory storage structure for directories


******

Bravo!  You have received a Medical Diploma in "Skull" from   
the Orbital Convergence University International Air and Water Embassy of the Tangerine Planet.  

You are now officially certified to include "Skull" in your practice.

******

# 💀 Skull

## obtain
(ZSH) pip install Skull

## tutorial
(ZSH) Skull shares
skull 0.0.1
memory storage structure for directories





name:
	skull

description:
	memory storage structure for directories


tutorial:
	skull.JSON needs to be added to a folder:
		'''
		skull.JSON {
			"basilosauri": {
				"port": ""
			},
			"skull ganglia": {
				"path": ""
			},
			"PFC": {
				"path": ""
			}
		}
		'''

	#
	# This sets up the skull climate 
	import skull
	skull.start ()

	import skull.ganglia.list as skull_ganglia_list
	list = skull_ganglia_list.start ()




structure:
	archives
	
	sandbox:
		climate.py <- setup the skull db
		open.py <- uses skull
	
	modules_pip
		skull
			climate.JSON <- tinydb
		
	modules.pip.UTF8
spyndle-web-api 0.1.1
A non-destructive Web API for Spyglass
Requires Python: >=3.9,<4.0

# Spyglass Web API

This is a web API for interacting with a Spyglass database. It is written in Python and uses FastAPI.

## Developer setup

Start a local spyglass instance. Instructions taken from [this notebook](https://github.com/LorenFrankLab/spyglass/blob/master/notebooks/00_Setup.ipynb).

```bash
# one time
docker pull datajoint/mysql:8.0
docker volume create dj-vol

# start the database
bash devel start-spyglass-database.sh
```

Clone spyglass and install it in development mode.

```bash
cd spyglass
pip install -e .
```

Configure spyglass.

```bash
cp dj_local_conf_example.json dj_local_conf.json
# Then edit dj_local_conf.json to set the database credentials and the directories for the data.

# Make sure to set "custom.no_prompts_mode": true, in the config file.
```

Set SPYGLASS_CONFIG_PATH to point to the spyglass config file, then run:

```bash
python devel/check-config.py
```

Install sgwa in development mode

```bash
pip install -e .
```

Start the web API.

```bash
# start the web API
bash devel/start-sgwa.sh
```

Check the database connection

```bash
python devel/check-db-connection.py
```
python-file-storage 0.3.0
A Python package that exposes a consistent API for working with different storage backends.
Requires Python: >=3.8

# python-file-storage

A Python package that exposes a consistent API for working with different
storage backends.

WARNING: This is still under active development.


## Why does this package exist?

I needed something that does not depend on Django but exposes a similar
interface to Django's base storage in `django.core.files.storage.base.Storage`.
So, if you're using Django: use Django and [django-storages][2] instead.
Currently, this package only does the bare minimum that I need it for so
if you're looking for something more full-featured perhaps look at the
[cloudstorage][3] package.


## Available backends

- Filesystem.
- Amazon S3.


## Quickstart

1. Install the package:
   ```
   pip install python-file-storage
   ```

1. Add your configuration. Set the following as environment variables or add
   them to a `.env` file in the root of your project:

   ```python
   DEFAULT_STORAGE_BACKEND = storage.backends.s3.S3Storage
   S3_BUCKET_NAME = my-bucket-name
   S3_ENDPOINT_URL = example.com # Optional
   S3_ACCESS_KEY_ID = 123
   S3_SECRET_ACCESS_KEY = 123
   ```

   Currently, using more than one storage backend at a time is unsupported.

1. Import `default_storage` and start using the package:

   ```python
   from storage import default_storage

   default_storage.save('example.txt', 'Content')
   file = default_storage.open('example.txt', 'Content')
   ```


## Compatibility

- Python 3.8+
- Django is unsupported.


## Versioning

This project follows [semantic versioning][1] (SemVer).




[//]: # (Links)

[1]: https://semver.org/
[2]: https://github.com/jschneier/django-storages
[3]: https://github.com/scottwernervt/cloudstorage
python-caspass 0.1.2
CASPass - Login through Central Authentification Systems
Requires Python: >=3.11,<4.0

# CASPass - Login through Central Authentification Systems

## Motivation

When you write a web scraper, Central Authentification Systems are often
difficult to get through. Most of them use a lot of Javascript and protection
mechanisms, so it's complex to automate. Moreover, you need to understand a
completely different logic, which is useless with respect to the website you
want to scrap.

The chosen approach for `CASPass` is to avoid completely to understand the CAS
logic and to rely on a full browser, namely
[Playwright](https://github.com/Microsoft/playwright-python), to authenticate.
This a semi-automatic process since you need to manually enter your credentials,
on the login page you are used to work with. But it's only needed one time,
`CASPass` save all the cookies into a file which can be used by a traditional
scrapper library (like [requests](https://requests.readthedocs.io/) or
[httpx](https://github.com/encode/httpx)).

Obviously this semi-automatic approach is not usable in a fully non-interactive
context, like a CI/CD system. However, it has many advantages:

- no need to understand the CAS,
- no need to bother with Captcha,
- no complex logic to understand,
- moreover, most of the authentication tokens stored in cookies have a pretty
  long duration, so you will only have to manually log in from time to time.

`CASPass` works also without a CAS: when the login process is full of
Javascript, Captcha or other security checks and too complex to automate, just
use this module to authenticate and then perform the scraping with a more
efficient tool.

## Installation

    pip install python-caspass

or 

    pip install git+https://codeberg.org/oschwand/python-caspass

## Usage

The `CASPass` constructor expects two arguments:

- a list of URL leading to the login page (you may need to provide multiple
  links in order to satisfy the security checks)
- the success URL, reached after successful login (it indicates the login
  process is terminated)

``` python
from caspass import CASPass

cas = CASPass([url, url_login], url_success)
cas.login()
cas.save("cookies.txt")
```

See `examples/` for some complete examples.

# Licence

GPLv3+
sqlinks 0.0.4
Diagramming SQL data pipelines.
Keywords: python,documentation,sql

Documenting data pipelines is hard. Not only is it complex, but it's also time consuming. When working with big teams it becomes near impossible; documentation is out of date as soon as it's completed as there's continual change. **sqlinks** hopes to remedy this by allowing you to generate flow diagrams programatically. This allows for reproducable and clear diagrams that, by using [diagrams.net](diagrams.net), are also easily accessible by non-technical users.