semvec/pypi-packages huggingface dataset:
closeformIK 1.0.8
robot6Ik Package with dynamic libraries for both Linux and Windows
Requires Python: >=3.9

`closeformIK` is an analytical inverse kinematics calculation library for a 6-DOF robotic arm. When solving for inverse kinematics, you should call the `CIK` function. Below is the description of the input parameters for the function:

- `eeTform`: End-effector trans 4x4 matrix
- `MdhParams`: DH parameter table including `d`, `a`, `alpha`, `theta`
- `jointlimits`: Joint angle limits
- `joint_ref`: Reference joint angles

Here's a typical application example:

```python
from closeformIK import CIK
import numpy as np

# Define Modified Denavit-Hartenberg parameters
MdhParams = np.array([
    [a1, alpha1, d1, theta1],
    [a2, alpha2, d2, theta2],
    [a3, alpha3, d3, theta3],
    [a4, alpha4, d4, theta4],
    [a5, alpha5, d5, theta5],
    [a6, alpha6, d6, theta6]
])

# Define joint angle limits
Jointlimits = [
    [limit_n_j1, limit_p_j1],  # Joint 1
    [limit_n_j2, limit_p_j2],  # Joint 2
    [limit_n_j3, limit_p_j3],  # Joint 3
    [limit_n_j4, limit_p_j4],  # Joint 4
    [limit_n_j5, limit_p_j5],  # Joint 5
    [limit_n_j6, limit_p_j6]   # Joint 6
]

# Compute the inverse kinematics solution
sol, allsol = CIK(eeTform, MdhParams, Jointlimits, joint_ref=joint_ref)
jjcli 0.1.29
# Name

# Name

 jjcli - python module for command-line filter

# Synopsis

as ascript:

    jjcli skel     ## a initial filter skeleton
    jjcli          ## manual

as a module: 

    from jjcli import *       ## re.* functions also imported
    cl=clfilter(opt="do:", doc=__doc__) 
                              ## options in cl.opt  (...if "-d" in cl.opt:)
                              ##    autostrip         (def=True)
                              ##    inplace           (def=False) 
                              ##    fs (for csvrow()) (def=",")
                              ##    doc=__doc__     (for --help)
                              ##    longopts=["op1",...]

    for line in cl.input():...    ## process one rstriped line at the time
    for txt in cl.text():...      ## process one striped text at the time
        ## process txt            ##   (end of line spaces and \\r also removed)
    for par in cl.paragraph():... ## process one striped paragraph at the time
    for tup in cl.csvrow():...    ## process one csv row at the time
    for tup in cl.tsvrow():...    ## process one tsv row at the time

    cl.lineno()         ## line number
    cl.filelineno()
    cl.parno()          ## paragraph number
    cl.fileparno()
    cl.filename()       ## filename or "<stdin>"
    cl.nextfile()
    cl.isfirstline()
    cl.args  cl.opt     ## command line arguments and options (after clfilter())

# Description

__jjcli__ is a opinioned Python module that tries to simplify the creation of
__unix__ filters. It is based on:

- getopt  (for command line options and args)
- fileinput (for [files/stdin] arguments)
- re (regular expressions should be native)
- glob (glob.glob should be native)
- csv  (for csv and tsv inputs)
- urllib.request (to deal with input argumens that are url)
- subprocess 

## Regular expressions

We want to have all re.* functions available (as if they were native
functions).

In order to enable __re__ flags, use: re.I re.X re.S  

## Subprocesses   (qx, qxlines, qxsystem, qxerr)

    a=qx( "ls" )
    for x in qxlines("find | grep '\.jpg$'"): 
      ...
    qxsystem("vim myfile")

### Execute command return its stdout-str
    qx(*x)      →  returns    subprocess.getoutput(x)

### Execute command return its stdout-str lines
    qxlines(*x) →  returns    subprocess.getoutput(x).splitlines()

### Execute command and return its (stdout-str, stderr-str)
    out,err = qxexec(*x) →    returns Popen(x,PIPE, PIPE,shell=True).communicate()

## STDERR - warn, die

    warn(*args)  → print to stderr
    die(*args)   → warn and exit 1

## Other functions

    slurpurlutf8(self,f)

    filename    = lambda s : F.filename()      # inherited from fileinput
    lineno      = lambda s : F.lineno()
    filelineno  = lambda s : F.filelineno()
    parno       = lambda s : s.parno_          # paragraph number
    fileparno   = lambda s : s.fileparno_
    nextfile    = lambda s : F.nextfile()
    isfirstline = lambda s : F.isfirstline()
    isfirstpar  = lambda s : s.fileparno == 1
    close       = lambda s : F.close()
dbdicom 0.2.6
A pythonic interface for reading and writing DICOM databases
Requires Python: >=3.6
Keywords: python, medical imaging, DICOM

`dbdicom` is a Pythonic interface for reading and writing DICOM databases.

# Installation

`pip install dbdicom`

# Documentation

For more detail, see the current [dbdicom documentation](https://qib-sheffield.github.io/dbdicom/).

# Ambition

The DICOM format is the universally recognised standard for medical imaging, 
but working with DICOM data remains a challenging task for data scientists. 

``dbdicom`` aims to provide an intuitive programming interface for reading and 
writing DICOM databases - replacing unfamiliar DICOM-native concepts by 
pythonic language and syntax. 

# Disclaimer

`dbdicom` is developed in public and currently trialled in ongoing 
multi-centre clinical studies 
[iBEAt](https://bmcnephrol.biomedcentral.com/articles/10.1186/s12882-020-01901-x>) 
and [AFiRM](https://www.uhdb.nhs.uk/afirm-study/). However, ``dbdicom`` is 
work in progress and **not yet sufficiently stable for wider use**. Current 
dissemination activities, such as on the 
[ISMRM (Toronto 2023)](https://www.ismrm.org/23m/), are limited in scope and 
intended to get early feedback from the community.
bio-attention 0.1.15
Simple implementations of attention modules adapted for the biological data domain
Requires Python: >=3.8

<div align="center">
<h1>bio-attention</h1>

Simple implementations of attention modules adapted for the biological data domain.

[![PyPi Version](https://img.shields.io/pypi/v/bio-attention.svg)](https://pypi.python.org/pypi/bio-attention/)
[![GitHub license](https://img.shields.io/github/license/gdewael/bio-attention)](https://github.com/gdewael/bio-attention/blob/main/LICENSE)
[![Documentation](https://readthedocs.org/projects/bio-attention/badge/?version=latest&style=flat-default)](https://bio-attention.readthedocs.io/en/latest/index.html)

</div>

## Why use this package?

There are already plenty of excellent implementations out there that allow you to test out the countless variants of transformers [[1]](https://github.com/facebookresearch/xformers), [[2]](https://github.com/lucidrains/x-transformers).
This repository primarily separates itself from the previous in that it contains positional encodings schemes adapted to allow for irregularly-spaced positions in sequences.
This is useful in, for example: (1) the mass spectral domain (proteomics, metabolomics, ...), where transformers operate on sets of peaks, (2) any kind of (epi)genomic data that measures sites of interests on the genome that are irregularly-spaced (such as WGBS/CpG sites, ATAC-seq/chromatin accessibility, ...).
Additionally, the attention definitions in this repository are compatible with multi-dimensional data, such as the MSAs used in some protein language models, and AlphaFold.

## Install
Since PyTorch is a dependency of `bio-attention`, we recommend [installing PyTorch](https://pytorch.org/get-started/locally/) independently first, as your system may require a specific version (e.g. CUDA drivers).

After PyTorch installation, `bio-attention` can be installed using `pip`
```bash
pip install bio-attention
```

## Note

This package used to be a 2D sliding window attention package. The current formulation of the package does not allow for this type of attention anymore (instead, I recommend to perform axial attention with alternating sliding window attention across one axis and full self-attention across the other). If you want to use 2D sliding window attention, check out the [old version of this repo](https://github.com/gdewael/bio-attention/tree/ac3cb87906a2ff7adf9de393a5d2bbd3bf11eef3).

## Usage

## Package roadmap

- [x] Embedding layers
  - [x] Continuous
  - [x] Discrete
  - [x] Binary
  - [x] Bin
- [~] Positional encoding schemes
  - [x] Sinusoidal
  - [x] Embedding
  - [x] Continuous
  - [x] Rotary
  - [x] AliBi
  - [x] DPB
  - [x] XL
  - [x] Test support for multi-dimensional inputs
- [~] Attention modules
  - [x] Vanilla
  - [x] Windowed
  - [x] Random
  - [x] Performer
  - [x] Encoder
  - [x] Decoder
  - [x] Cross
  - [x] Support for multi-dim inputs
- [ ] Add a warning if non-increasing positional indices are used with a decoder attention
- [ ] Add docs clarifying that clf tokens are automatically accounted for if no pos is provided for them
- [ ] Tests
- [x] Typing
- [x] Docs
AGeneticosJ 0.1.2
Una libreria para Algoritmos Geneticos
Requires Python: >=3.8

librerias-ag

librerias-ag es una librería de Python diseñada para experimentar con algoritmos genéticos básicos y funciones de optimización. Incluye herramientas para generar poblaciones, aplicar mutaciones simples y minimizar funciones objetivo, con soporte opcional para visualización del progreso en cada generación.

Características

- Definición de funciones objetivo personalizadas (ej. \( f(x) = x^2 \)).
- Generación aleatoria de individuos y poblaciones.
- Simulación simple de evolución por selección y mutación.
- Visualización de la minimización de la función en gráficas.
- Ideal para aprender conceptos básicos de optimización evolutiva.
sfchecks 1.6.5
A library for writing checks for SecureFlag's hands-on secure coding training labs

# sfchecks

`sfchecks` is a Python library written by [SecureFlag](https://www.secureflag.com/) for writing automated checks to determine the status of a training exercise in SecureFlag's hands-on secure coding labs.

To learn how to use `sfchecks` if you are creating your own exercises, head over to the [documentation](https://secureflag.gitlab.io/sf-tool-sfchecks/sfchecks.html).
expetator 0.3.28
A framework for monitoring HPC applications using DVFS
Requires Python: >=3.6

# expetator

A tool for running HPC benchmarks using several type of leverages (DVFS) and low-level monitoring (hardware performance counters, RAPL) mostly on Grid5000.

Documentation is available here: https://expetator.readthedocs.io/

Source code is available here: https://gitlab.irit.fr/sepia-pub/expetator

To install expetator:

	pip3 install expetator