semvec/pypi-packages huggingface dataset:
html-calendar 0.0.24
html-calendar


HTML Calendar
=============

This module has the simple purpose of building html calendar tables with links
and formatting. It is totally framework agnostic.

The module provides the ``htmlcalendar`` Python function that takes an starting
date and a number of months for rendering the HTML Tables containing the
specified months with formated cells and HTML links on day's numbers.

Formatting is provided by passing a callback function as the ``classes``
parameters that takes the date and returns a list of CSS classes that are
applied to the date's cell.

Linking dates to URLs is also provided by a callback function passed as the
``links`` parameter that takes the date and returns a fully qualified HTML link
if required or ``None`` if not.

For formatting the headers and the table you can use css classes in a list with
the options ``th_classes`` and ``table_classes``.

Attributes dictionary is added for allowing further customization of the
calendar with the keyword ``attrs``. Then, for ensuring safety on the building
of the calendar the ``safe`` option is added to escape all the variables that
are rendered building the calendar when it is disabled.

It also supports North American calendar with the option ``caltype`` putting
its value to 1.

.. code-block:: python

  from flask import Flask
  from datetime import date
  from htmlcalendar import htmlcalendar

  app = Flask("party")

  def links(date):
	  if date.weekday() == 5:
		  return "https://github.com/llou/html-calendar"

  def css_class(date):
	  if date.weekday() == 5:
		  return ["party"]

  def attrs(date):
      return {"onclick": f"whatever({date.year}, {date.month}, {date.day})"}

  @app.route("/")
  def party_calendar():
	  return htmlcalendar(date.today(), months=1, links=links, classes=css_class)

You can read the documentation at https://html-calendar.readthedocs.io/en/latest/
convolog 0.0.3
A small package used for creating conversation logs.
Requires Python: >=3.8

# Convolog

A small package used for creating conversation logs

> Started conversation at 2024-07-10 18:38:33
2024-07-10 18:38:33 [Alice]: Hello, how are you?
2024-07-10 18:38:33 [Bob]: I'm doing well, thank you!

## Basic Usage

**Installation**

> pip install convolog

**Template Code**

    from convolog import Conversation
    import  time
    if __name__ == '__main__':
	    convo = Conversation("session1")
	    convo.add_log("Alice", "Hello, how are you?")
	    convo.add_log("Bob", "I'm doing well, thank you!")
	    time.sleep(5)
	    convo.delete_conversation()

I dont want to create a documentation for this so here's the entire documentation:

## Conversation Class
|Function|Description |
|--|--|
|Conversation(identifier: str, file_path: str = None)  | Creates a conversation (will automatically create a file)  |
|get_read_file()  | Returns the file with read permissions  |
|get_write_file()  | Returns the file with write permissions  |
|add_log(source: str, message: str)  | Adds a conversation log  |
|delete_conversation()  | Deletes the conversation file (may be dangerous idk) |
pygame-util 1.0.5
A package that simplifies repetitive pygame code.
Requires Python: <4.0,>=3.11

# Pygame Util
A package that simplifies repetitive pygame code.

## Window

Here's how you would do it in pygame:
```
window = pygame.display.set_mode((600, 400))
window.set_caption("example caption")
window.set_icon(example_icon)

background_color = (255, 255, 255)

clock = pygame.time.Clock()
fps = 60

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    clock.tick(fps)
    window.fill(background_color)

    # render the images you want to show on the screen

    pygame.display.flip()
```


Here's how you would do it in pygame_util:
```
window = Window((600, 400), icon=icon, caption="example_caption", force_quit=True)

while True:
    # render images you want to show on the screen
    window.update()
```
## Text

## Images

## Colors

## Timers

## Positioning
sferriol-wamp 0.2.2
WAMP utilities
Requires Python: <3.12,>=3.11.0

# sferriol-wamp

sferriol-wamp is a module of WAMP utilities

## Installation

### From pypi

    pip install sferriol-wamp

### From source

    git clone https://gitlab.in2p3.fr/sferriol-ip2i/sferriol-wamp.git
    cd sferriol-wamp
    pip install .

with dev environment

    pip install .[dev]


## Usage

TBD
IntFeat 0.1.0
A package for image registration using SIFT, ORB, and IntFeat.
Requires Python: >=3.6

## MoonMetaSync: Lunar Image Registration Analysis

This study compares scale-invariant (SIFT) and scale-variant (ORB) feature detection methods in addition to a custom feature detector (IntFeat) using low (128x128) and high-resolution (1024x1024) image patches. Key to this analysis is the upscaling of low-resolution images to match the higher resolution via bi-linear and bi-cubic interpolation methods, providing a unique perspective on the effectiveness of image registration using these methods across different scales and feature detectors. The baseline is defined as up-scaling the low-resolution images without image registration.

**Research Questions**
1. Which interpolation method works better for high-contrast lunar images?
2. Does using a combined feature detection module give better results on up-scaled images?

**Discussions**

1. Adapting to the distinct characteristics of lunar images is challenging due to their sharp shadow boundaries resulting in high contrast regions with substantial differences in brightness, posing a significant challenge for feature detection algorithms.
2. Noise Level Concerns: The IntFeat detector may have amplified noise, particularly artifacts from ORBâ€™s low-level feature extraction. This amplification seems to occur during the smoothing of textural details during image interpolation
3. IntFeat Limitations: The detector's performance is hindered by a combination of factors such as high noise levels, stark contrast differences, homogenous textures, and fluctuating lighting conditions, which adversely affect the integration of both low and high-level features.

**Conclusion and Future Work**

Bi-cubic typically outperforms bi-linear interpolation in the realm of image processing. The reliance on bi-cubic interpolation on a larger 4x4 neighborhood does not extend to lunar images due to inherent noise and high-contrast features. The custom feature detector, IntFeat, yields comparable results to the baseline. The current implementation does not outperform existing detectors. It underscores the need for further refinement in key points filtering methods and descriptors that can handle high-contrast environments and noise levels of lunar surfaces.
MoonMetaSync 0.1.0
A package for image registration using SIFT, ORB, and IntFeat.
Requires Python: >=3.6

## MoonMetaSync: Lunar Image Registration Analysis

This study compares scale-invariant (SIFT) and scale-variant (ORB) feature detection methods in addition to a custom feature detector (IntFeat) using low (128x128) and high-resolution (1024x1024) image patches. Key to this analysis is the upscaling of low-resolution images to match the higher resolution via bi-linear and bi-cubic interpolation methods, providing a unique perspective on the effectiveness of image registration using these methods across different scales and feature detectors. The baseline is defined as up-scaling the low-resolution images without image registration.

**Research Questions**
1. Which interpolation method works better for high-contrast lunar images?
2. Does using a combined feature detection module give better results on up-scaled images?

**Discussions**

1. Adapting to the distinct characteristics of lunar images is challenging due to their sharp shadow boundaries resulting in high contrast regions with substantial differences in brightness, posing a significant challenge for feature detection algorithms.
2. Noise Level Concerns: The IntFeat detector may have amplified noise, particularly artifacts from ORBâ€™s low-level feature extraction. This amplification seems to occur during the smoothing of textural details during image interpolation
3. IntFeat Limitations: The detector's performance is hindered by a combination of factors such as high noise levels, stark contrast differences, homogenous textures, and fluctuating lighting conditions, which adversely affect the integration of both low and high-level features.

**Conclusion and Future Work**

Bi-cubic typically outperforms bi-linear interpolation in the realm of image processing. The reliance on bi-cubic interpolation on a larger 4x4 neighborhood does not extend to lunar images due to inherent noise and high-contrast features. The custom feature detector, IntFeat, yields comparable results to the baseline. The current implementation does not outperform existing detectors. It underscores the need for further refinement in key points filtering methods and descriptors that can handle high-contrast environments and noise levels of lunar surfaces.
magic-top-hat 0.1.0
Add your description here
Requires Python: >=3.8

# Top Hat

Do you know how magicians could pull stuff out of an apparently empty top hat?

I only recently discovered how that worked, and apparently it was dunder methods all along! Who would have thought!

So I decided to implement something similar in Python: you can import any method whatsoever from this magical `magic_top_hat`, even if the module itself seems empty!

```python
import magic_top_hat

dir(magic_top_hat) # returns []
```

BUT! With sleight of hand you can actually import anything you want out of the `magic_top_hat`:

```python
from magic_top_hat import get_day_out_of_datetime
from datetime import datetime

def get_today_day() -> str: 
    today = datetime.now()
    day = get_day_out_of_datetime(today)
    return day # this will return the day name
```

and a function will be generated that satisfies your every need*!

Do you need to know how the function generated your result? No, right? Implementation is just a detail for the code monkeys! If you really have no trust in this (as you should), you can set the environmental variable `I_DONT_TRUST_ROBOTS` to have each implementation printed out.

*satisfaction not guaranteed. You will need to set a `OPENAI_API_KEY` env parameter for this to work. And even then, it might not work.

## How

Well, I simply send the caller code to OpenAI and ask ChatGPT to generate a function that will fulfill the request, given the context in which it was called, the name it was given and the parameters it received.

So the results may vary from abysmal to groteque.

## Why

It was really fun to try and build something like this, also I had a couple of hours to kill before sleep. Also, I can honestly say that this is AI powered!

### Examples

Look at `scripts/example.py` for a couple of simple examples!
status-manager 1.0.3
simple and useful status manager for bulk computations
Keywords: status-manager, status, computation


# status-manager python library
[![Upload Python Package](https://github.com/J-Saeedi/status-manager/actions/workflows/python-publish.yml/badge.svg?branch=main)](https://github.com/J-Saeedi/status-manager/actions/workflows/python-publish.yml)
## simple and useful status manager for bulk computations
Assume that you have multiple folders which each one have a complete and isolated computation task.
When you need to run them in sequence, may be it waste your time to count the current stage of each one. With this library you can easily handle the progress of each computation inside their own folders.    

# Usage
For example assume there are 4 folders inside the working directory, each one has a computation of calculating solar energy of a planet. Now you are going to start computation for them which are not finished from previous attempts. I mean something like this:
```python
for i in range(1, 5):
        task = f"task-{i}"
        os.system(f"{task}/run_calculations") # run calculations
```

By using `status-manager`, it will be very easy! See this example:

# Example

```python
from status_manager import CheckStatus, StatusType

s = CheckStatus() # init the status manager

for i in range(1, 5):
        task = f"task-{i}"
        status = s.check(task) # read status of this task
        if status != StatusType.finished:
            os.system(f"{task}/run_calculations") # run calculations
            status.write_status(task, StatusType.finished) # save as finished
```
CellNeighborEX 1.0.1
library for neighbor-dependent gene expression analysis
Requires Python: <3.11,>=3.8

[![PyPI](https://img.shields.io/pypi/v/CellNeighborEX?logo=PyPI)](https://pypi.org/project/CellNeighborEX)

CellNeighborEX: Deciphering Neighbor-Dependent Gene Expression from Spatial Transcriptomics Data
====================================================================================
<p align="justify">CellNeighborEX is a computational approach to identify genes up-regulated or down-regulated by immediate neighbors from spatial transcriptomics (ST) data at single cell or near cellular resolution. It works for both image-based and NGS-based ST data. For image-based ST data where exact cell locations are available, CellNeighborEX uses various algorithms including Delaunay triangulation and KNN to find immediate neighbors. For NGS-based ST data where exact cell locations are not available, CellNeighborEX leverages the mixture of transcriptomes in each spot. CellNeighborEX dissects cells or spots based on the cell types of the immediate neighbors. Carrying out differential expression analysis for the categorized cells or spots, CellNeighborEX detects neighbor-dependent genes. The expression of neighbor-dependent genes is validated in the spatial context.</p> 

The figure below shows the workflow of CellNeighborEX:

![Fig 1](https://user-images.githubusercontent.com/99720939/229945240-2c9a2ef9-2566-496f-9981-0823cd95b813.png)

## Installation
<p align="justify">CellNeighborEX requires Python version >=3.8, <3.11. We recommend using conda environment to avoid dependency conflicts. The dependencies are listed in requirements.txt.</p> 

<pre><code># Create conda environment “myenv”
conda create -n myenv python=3.10
conda activate myenv

# Navigate into the directory where requirements.txt is located. Then, install dependencies
pip install -r requirements.txt

# Install CellNeighborEX from PyPI
pip install CellNeighborEX
</code></pre>

## Python API documentation and tutorials
Please see this [Read the Docs](https://CellNeighborEX.readthedocs.io/en/latest/). 

## Citation
Hyobin Kim, Amit Kumar, Cecilia Lövkvist, António M. Palma, Patrick Martin, Junil Kim, Praveen Bhoopathi, Jose Trevino, Paul Fisher, Esha Madan, Rajan Gogna, and Kyoung Jae Won, CellNeighborEX: Deciphering Neighbor-Dependent Gene Expression from Spatial Transcriptomics Data, _Molecular Systems Biology_, 19(11), e11670, 2023. [Link](https://doi.org/10.15252/msb.202311670).