Saravanan666/pypi-org huggingface dataset:
Package: halofactory
HaloFactory - Semi-analytical dark matter halo generatorsIn astrophysics, it is known that dark matter halos building blocks of the Universe's large-scale structures.
Given their significance in theoretical and numerical studies of galaxy formation,
it is imperative to generate halo catalogs not only following closely to
structure formation theory but also being efficient in computation.This repository presents a comprehensive collection of semi-analytical methods
that facilitate the generation of halo catalogs and their corresponding merger trees.
These methods are either purely theoretical or calibrate by numerical simulations.
Building upon this repository, we intend to publish another repository dedicated
to "semi-analytical galaxy formation models", which will utilize the
halo-to-galaxy connection to populate halos with galaxies.It is important to note that this package is currently in the process of being
developed and is subject to structural modifications and functional expansions.
The documentation is currently empty, and the testing does not encompass the
entire source tree. We will continue to work towards completing these aspects.Dependencies:Python>=3.9.pyhipp>=0.0.2, scipy, numpy.To installhalofactoryand automatically handle the dependencies, usePyPI:pipinstallhalofactoryInteresting FeaturesHalo Density Profile. HaloFactory predefines a set of density profiles for
halos. For example, the following codes defines an NFW profile instance:>>>fromhalofactory.profileimportNFWProfile>>>profile=NFWProfile(mass=1.0e2,rs=10.0)>>>profile{'type':'NFWProfile','_meta':{'mass':100.0,'rin':0.0001,'xin':1e-05,'rvir':150.0,...},'_us':{'u_l':'3.085677581491367e+19 m','u_t':'3.085677581491367e+16 s','u_m':'1.988409870698051e+40 kg',...}}The printed message includes the metainfo (mass, virial radius, etc.) of the halo,
as well as the unit system in use.To find information of the profile at given radii, for example, the density, write:>>>profile.rho([1.,2.,3.])array([0.03583832,0.01505707,0.00855313])To sample from the profile and thus create a set of particles used as input for
N-body simulation, define a sampler such as the Eddington Inversion sampler:>>>fromhalofactory.initial_conditionimportEddInv>>>sampler=EddInv(profile)>>>sampler{'type':'EddInv','_profile':{'type':'NFWProfile',...},'_rng':<pyhipp.stats.random.Rngobjectat0x15092bc90>,'_meta':{'mass':100.00000000000001,'Et':0.0,'m_hi':1.0,...}}The message indicates the method of the sampler, the input profile, the random
number generator, and various of metadata.To generate a sample, e.g., 1000 particles, write:>>>sample=sampler.get(1000)>>>sample.pos,sample.vel,sample.mass(array([[-27.04020173,60.70242802,-6.84922322],...]),array([[12.7955374,-114.31584255,30.89851955],...]),0.10000000000000002)The returnedsampleinstance contains positions, velocities and mass of the sampled
particles.More is coming ...
Package: halo-flask
HaloTheHaloLib is a python based library utilizingServerlesstechnology andmicroservices architectureHalo provides the following features:Flask development for AWS Lambda & Dynamodbcorrelation id across microservicesstructured json based loggingsample debug log in productionsupport for microservice transactions with the saga patternusing SSM Parameter Store over Lambda env variablesServerless Error Handling & trace id for end usersLambda timeoutmanagement forslow HTTP responsesootb support for Idempotent service invocations (md5)If you are building a Python web app running on AWS Lambda (Django or Flask), use this library to manage api transactions:sagax = load_saga("test", jsonx, schema)
            payloads = {"BookHotel": {"abc": "def"}, "BookFlight": {"abc": "def"}, "BookRental": {"abc": "def"},
                        "CancelHotel": {"abc": "def"}, "CancelFlight": {"abc": "def"}, "CancelRental": {"abc": "def"}}
            apis = {"BookHotel": self.create_api1, "BookFlight": self.create_api2, "BookRental": self.create_api3,
                    "CancelHotel": self.create_api4, "CancelFlight": self.create_api5, "CancelRental": self.create_api6}
            try:
                self.context = Util.get_lambda_context(request)
                ret = sagax.execute(self.req_context, payloads, apis)
                return {"saga": "good"}, 200
            except SagaRollBack as e:
                return {"saga": "bad"}, 500LicenseThis project is licensed under the MIT LicenseAcknowledgmentsYan Cui -https://theburningmonk.comflowpl -https://github.com/flowpl/saga_py
Package: halohome
halohomeA python library to control Eaton HALO Home Smart LightsChangelog0.5.0 2022-01-25Sort devices by RSSI before connecting to avoid unnecessary delay0.4.0 2021-11-08(BREAKING)Remove support foruser_id(username/email is sufficient)Support offline loading of devices (e.g. in case of internet outage)0.3.0 2021-10-25Readuser_idto provide a permanent ID for the HALO Home account0.2.1 2021-10-23Raise HaloHomeError when credentials are not valid0.2.0 2021-10-21Support mesh communication (only need to connect to a single device
to control all of them)Make network and bluetooth connections async0.1.0 2021-10-17Initial release
Package: halohomeapi
halohomeA python library to control Eaton HALO Home Smart LightsChangelog0.5.0 2022-01-25Sort devices by RSSI before connecting to avoid unnecessary delay0.4.0 2021-11-08(BREAKING)Remove support foruser_id(username/email is sufficient)Support offline loading of devices (e.g. in case of internet outage)0.3.0 2021-10-25Readuser_idto provide a permanent ID for the HALO Home account0.2.1 2021-10-23Raise HaloHomeError when credentials are not valid0.2.0 2021-10-21Support mesh communication (only need to connect to a single device
to control all of them)Make network and bluetooth connections async0.1.0 2021-10-17Initial release
Package: halolib
HaloTheHaloLib is a python based library utilizingServerlesstechnology andmicroservices architectureHalo provides the following features:Django and/or Flask development for AWS Lambda & Dynamodbcorrelation id across microservicesstructured json based loggingsample debug log in productionsupport for microservice transactions with the saga patternusing SSM Parameter Store over Lambda env variablesServerless Error Handling & trace id for end usersLambda timeoutmanagement forslow HTTP responsesootb support for Idempotent service invocations (md5)If you are building a Python web app running on AWS Lambda (Django or Flask), use this library to manage api transactions:sagax = load_saga("test", jsonx, schema)
            payloads = {"BookHotel": {"abc": "def"}, "BookFlight": {"abc": "def"}, "BookRental": {"abc": "def"},
                        "CancelHotel": {"abc": "def"}, "CancelFlight": {"abc": "def"}, "CancelRental": {"abc": "def"}}
            apis = {"BookHotel": self.create_api1, "BookFlight": self.create_api2, "BookRental": self.create_api3,
                    "CancelHotel": self.create_api4, "CancelFlight": self.create_api5, "CancelRental": self.create_api6}
            try:
                self.context = Util.get_lambda_context(request)
                ret = sagax.execute(self.req_context, payloads, apis)
                return {"saga": "good"}, 200
            except SagaRollBack as e:
                return {"saga": "bad"}, 500LicenseThis project is licensed under the MIT LicenseAcknowledgmentsYan Cui -https://theburningmonk.comflowpl -https://github.com/flowpl/saga_py
Package: halon-api
halon-apiA Python wrapper for the API for Mail Transport Agent Halon build with therequestslibrary.
The functions in the wrapper are described indoc/functions.mdin the project repository.Please read the originalHalon documentationfor
complete in depth documentation on function arguments and the data returned by the API.The wrapper is available as a PyPI packagehalon-api.InstallInstall the PyPI package usingpip:pip install halon-apiHow to usefrom halon_api import HalonAPI

h = HalonAPI(
    "halon.example.com",
    "halon-user",
    "secret-password",
)

print("Halon software version:", h.get_software_version())If you want to use your own CA (certificate authority), you can set the environment
variableREQUESTS_CA_BUNDLEto hold the path to a CA_BUNDLE. You can also pass
the pass the path to theHalonAPIobject with the argumentverify.
Read more in therequests documentation.DevelopmentHow to set up development environment.Setup virtual environmentMake virtual python environment:python -m venv .venvActivate environment:source .venv/bin/activateDeactivate virtual environment (When done):deactivateInstall softwareInstall required packages:pip install requirements.txtInstall required packages for development:pip install requirements-dev.txtUsepre-committo install git hook scripts:pre-commit installBuild the PyPI packageHow to build and install the PyPI package locally.Build the package:python -m buildInstall the package:pip install dist/halon-api-x.y.z.tar.gzGenerate documentationAutomated documentation of API functions can be generated bypydoc-markdown.
It will update the filedoc/functions.md.Generate markdown (from repo root):pydoc-markdown doc/pydoc-markdown.yaml
Package: haloop
haloopHaloop is a speech agent toolkit. Haloop provides:haiprogram to initialize models;hacprogram for acoustic model training;halfor RNN language model training and evaluation;halafor causal attention model training;hatfor agent testing.The package can be installed from PyPI:pip install haloopPretrained modelshatcan be used with Ukrainian GPT-2 models from our paperGPT-2 Metadata Pretraining Towards Instruction Finetuning for Ukrainian.You will need to install and download:pip install bitsandbytes sentencepiece

wget https://a.wilab.org.ua/gpt/wiki.model  # sentencepiece tokenizer
wget https://a.wilab.org.ua/gpt/ckpt10m.pt  # model checkpoint for GPT-2 LargeNow, kick off the REPL:hat --spm wiki.model ckpt10m.ptCitingPlease cite:@inproceedings{kyrylov-chaplynskyi-2023-gpt,
    title = "{GPT}-2 Metadata Pretraining Towards Instruction Finetuning for {U}krainian",
    author = "Kyrylov, Volodymyr  and
      Chaplynskyi, Dmytro",
    booktitle = "Proceedings of the Second Ukrainian Natural Language Processing Workshop (UNLP)",
    month = may,
    year = "2023",
    address = "Dubrovnik, Croatia",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2023.unlp-1.4",
    pages = "32--39",
    abstract = "We explore pretraining unidirectional language models on 4B tokens from the largest curated corpus of Ukrainian, UberText 2.0. We enrich document text by surrounding it with weakly structured metadata, such as title, tags, and publication year, enabling metadata-conditioned text generation and text-conditioned metadata prediction at the same time. We pretrain GPT-2 Small, Medium and Large models each on single GPU, reporting training times, BPC on BrUK and BERTScore on titles for 1000 News from the Future. Next, we venture to formatting POS and NER datasets as instructions, and train low-rank attention adapters, performing these tasks as constrained text generation. We release our models for the community at https://github.com/proger/uk4b.",
}ReadingSpeech Discrimination by Dynamic Programming, T. K. Vintsyuk (1968)
Package: halo-reader
HALO reader – tool for HALO Photonics wind doppler lidar post-processingPackage is under development and functionality/features might change.Feedback is welcome:mail|create issueFeaturesRead and merge raw files into a netCDF fileRead raw data directly fromCloudnetinto a netCDFVisualise dataInstallation# Requires Python 3.10 or newer# create a virtual environment (optional)python3-mvenvenv# activate the virtual environmentsourceenv/bin/activate# update pippipinstall-Upip# installpipinstallhalo-readerNotes for Windows Subsystem for Linux (WSL) usersYou can get Python 3.10 by installingUbuntu 22.04 from microsoft store.
In WSL, you may need to installbuild-essentialandpython3-devbefore installinghalo-reader.Usagehaloreader--help
haloreaderfrom_raw--help
haloreaderfrom_cloudnet--helpUse data from cloudnet# generate halo_warsaw_2023-03-16.nc file# and vis/halo_warsaw_2023-13-16.png visualisationhaloreaderfrom_cloudnet--sitewarsaw--date2023-03-16--plot# Browse generated visualisations at /vis directoryhaloboard# open your browser at localhost:5000Use raw fileshaloreaderfrom_rawStare_213_20230326_*.hplBackground_*0323-*.txt-oout.nc--plot# Browse generated visualisations at /vis directoryhaloboard# open your browser at localhost:5000Note that a good background correction requires around 300 or more background profiles.LicenseMIT
Package: halo-third-party-sdk-events
Halo Third Party SDK Events - Base components for verifying Halo EventsHalo Third Party SDK Events package is an extension package that will let developers verify the authenticity of events.What is Halo Third Party SDK for PythonThe Halo Third Party SDK for Python makes it easier for you to verify events and allows you to spend more time on implementing features and less on writing boiler-plate code.Difference between 2.x and 1.x versionsMessage validation was changed as a part of a security campaign.Quick StartInstallationImportantcryptographyis a dependency for this package. If you have not
already installedcryptography, you might need to
install additional prerequisites as detailed in thecryptography installation guidefor your operating system.Assuming that you have Python andvirtualenvinstalled, you can
install the package from PyPi as follows:$virtualenvvenv$.venv/bin/activate$pipinstallhalo-third-party-sdk-eventsThis package is not installed along-sidehalo-third-party-sdk-eventsstandard distribution,
and has to be installed separately.Usage and Getting StartedExample usage# 1. Import the necessary modules.importhalo_third_party_sdk_events.event_verification_handler# 2. Create handler object, if no arguments supplied both time and signature verifiers are used.verifier=halo_third_party_sdk_events.event_verification_handler.EventVerificationHandler()# 3. Call verify request with request headers and event body.verifier.verify_request_and_dispatch(requestHeaders,body)Opening IssuesFor bug reports, feature requests and questions, we would like to hear about it. Search the [existing issues](https://github.com/amzn/halo-third-party-sdk-for-python/issues) and try to make sure your problem doesn’t already exist before opening a new issue. It’s helpful if you include the version of the SDK and Python you are using. Please include a stack trace and reduced repro case when appropriate.LicenseThis SDK is distributed under the Apache License, Version 2.0, see LICENSE for more information.CHANGELOG2.0.0Message validation was changed as a part of a security campaign.1.0.0Initial release of Halo Third Party SDK.
Package: halo-third-party-sdk-model
Halo Third Party SDK Model - Model definitions for Halohalo-third-party-sdk-model is the model definitions package for Halo by
the Software Development Kit (SDK) team for Python.Getting HelpThe model definitions in this package are auto-generated. The issues and pull requests
on the repository are not monitored and may get closed without investigation. Please use
these community resources for getting help:Use theHalo Third Party SDKfor development and filing bugs.CHANGELOG1.1.0Activity data object was updated to include Activity Summary, and Activity Sessions now support intensity durations.Sleep data object was updated to include session start and end times.Notification type was updated to include ‘HEALTH_METRIC_DELETION’ and ‘HEALTH_METRIC_DELETION_TEST’.1.0.0Initial release of Halo Third Party SDK.
Package: hal-x
Hierarchical Agglomerative Learning (HAL)Package for performing clustering for high-dimensional data. This packages uses heavily scikit-learn and FFT accelerated t-SNE.System requirementHas been tested on latest version of OS X and Linux(OPTIONAL) The dynamical plotting requires Chrome, Safari or Firefox (withoutad blockers!).Requirement:Python 3.6 or later versions.Installing (once)Activate anAnacondaPython 3 environmentsource activate YOUR_CONDA_ENVIRONMENT
conda config --add channels conda-forge
conda install cython numpy fftw scipy
pip install hal-xUpdatingFor future versions of the package, you can upgrade using:pip install hal-x --upgradeSmall examplefrom hal import HAL  # this imports the class HAL() 
from sklearn.datasets import make_blobs
from hal import metric
import numpy as np

# Setting random seed, in case you want to re-run example but keep saved data in info_hal/ 
np.random.seed(0)

# Generate some data. 
X,ytrue = make_blobs(n_samples=10000,n_features=12,centers=10) # 10 gaussians in 12 dimensions, 10000 data points

# The HAL constructor has many optional parameters (documentation coming soon)
model = HAL(clf_type='svm', warm_start=False) # using linear SVMs (fastest) for agglomeration. Other options are 'rf' and 'nb' (random forest, and naive bayes)

# builds model -> will save data in file info_hal
model.fit(X)

# rendering of results using javascript (with optional feature naming)
feature_name = ['feat_%i'%i for i in range(12)]

# Now that your model is fitted, let's visualize the clustering hierarchy. This will give us an idea of how to choose the cv score for the final prediction
model.plot_tree(feature_name = feature_name)

# In the visualization, we see that cv above ~ 0.86 will yield perfect clustering
# In order to generate the corresponding final clustering labels, use the predict function
ypred95 = model.predict(X, cv=0.95) # Predict with score of 0.95
ypred50 = model.predict(X, cv=0.5) # Predict with score of 0.5

# You can check the accuracy of your predictions against the true labels using the convenient metric functions:
print("Normalized mutual information score: %.4f"%metric.NMI(ypred95, ytrue))
print("Normalized mutual information score: %.4f"%metric.NMI(ypred50, ytrue))

# The fitted model information is in directory info_hal. To reload that information for later use, just:
model.load()

# To load t-SNE coordinates:
model.load('tsne')
Package: ham2spec
ham2specThis is a Python extension written in Rust usingPyO3andmaturin.This module computes absorption and circular dichroism (CD) spectra from a Hamiltonian and a set of pigment positions and transition dipole moments. It's primarily used by thefmo_analysistool.InstallationRight now this only works on macOS because I only have a macOS system to test on. The primary hurdle to building on other systems is the dependency on LAPACK. Your system will need to have a LAPACK implementation installed, and you'll need to set the correctlapack_srcfeature.DevelopmentThe Python extension module requires acrate-typeof"cdylib", but running examples and requires acrate-typeof"rlib". In order to accommodate both you'll need to run tests via$ cargo test --liband examples via$ cargo run --no-default-features --example example_nameLicenseLicensed under either ofApache License, Version 2.0, (LICENSE-APACHEorhttp://www.apache.org/licenses/LICENSE-2.0)MIT license (LICENSE-MITorhttp://opensource.org/licenses/MIT)at your option.ContributionUnless you explicitly state otherwise, any contribution intentionally
submitted for inclusion in the work by you, as defined in the Apache-2.0
license, shall be dual licensed as above, without any additional terms or
conditions.
Package: hama
🦛 파이썬 한글 처리 라이브러리. PythonHangulMorphologicalAnalyzerFeatures텍스트 전처리 (Text preprocessing)형태소 분석 (Morpheme analysis)품사 태깅 (Part-of-speech tagging)License개발 가이드의라이센스문서를 참조하세요.InstallationPython 3.6+ 를 지원합니다.pip install hamaUsage개발 가이드에 Hama NLP의 여러 기능에 대한 사용법이 소개되어 있습니다.Testingcoverage run -m pytest -v
coverage report -mProfilingFrom the project root:python -m cProfile -o profile/out.profile profile/profile.py
python profile/timing.pyFormattingyapf -i -r -vv .
Package: hamamatsu
Hamamatsu python libraryThis library is used to control basic features of Hamamatsu cameras. It is
composed of a core library, an optional simulator and an optional lima plugin
together with itstangodevice class.It has been tested with C11440-36U model, but should work with other models.InstallationFrom within your favorite python environment type:$ pip install hamamatsuUsageimportloggingfromhamamatsu.dcamimportdcam,Streamlogging.basicConfig(level=logging.INFO)withdcam:camera=dcam[0]withcamera:print(camera.info)print(camera['image_width'].value,camera['image_height'].value)# Simple acquisition examplenb_frames=10camera["exposure_time"]=0.1withStream(camera,nb_frames)asstream:logging.info("start acquisition")camera.start()fori,frame_bufferinenumerate(stream):frame=copy_frame(frame_buffer)logging.info(f"acquired frame #%d/%d: %s",i+1,nb_frames,frame)logging.info("finished acquisition")LimaInstall extra dependencies with:$ pip install hamamatsu[lima]Command line usage:$ limatb hamamatsu scan$ limatb hamamatu -i 0 info$ limatb hamamatu -i 0 dump$ limatb hamamatu -i 0 acquire -n 10 -e 0.1TangoPlease refer to theLima documentationSimulatorOnly simulates a RemoteEx TCP interface.
Under development.
Package: hamapi
HAM Systems API for PythonWith this python package, you can easily access datalog data for yourHAM Systemsdevices.You are free to use this code as you like and we are looking forward to seeing on what you achieve with our platform!#!/usr/bin/env python3

import time, datetime
import math 

import hamapi

if __name__ == "__main__":
	# set you API key here
	ham = hamapi.hamapi(api_key='', server='hamsystems.eu')
	# unix timestamp of the start of data
	start = math.floor(time.time()-7*86400)
	# unix timestamp of the end of data
	end = math.floor(time.time()-86400)
	# step to smooth/average the data in seconds
	step = 2*60
	# get datalog data for device with serialno 12:204, from start to end with step
	data = ham.get_datalog_data("12:204", start, end)
	print(data)

	# fig, ax = plt.subplots()
	# ax.plot([datetime.datetime.utcfromtimestamp(d) for d in data['timestamp']], data['T'])
	# ax.grid()
	# plt.show()
Package: hamas-rocket
🚀 This is rocket 🚀package_namepackage_nameis a Python library for ..........InstallationUse the package managerpipto installpackage_name.pipinstallpackage_nameUsageimportpackage_name# returns 'words'package_name.module_name('word')# returns 'geese'package_name.module_name('goose')# returns 'phenomenon'package_name.module_name('phenomena')LicenseMIT
Package: hamble
HambleDescription: a simple pip package command line tool for populating a file with parameters from an ini file
using jinja2 templating.Usage:hamble [OPTIONS]

Options:
  -i, --ini TEXT     INI file with needed information  [required]
  -c, --config TEXT  config file needed to populate values from ini file into
                     [required]
  --help             Show this message and exit.
Package: hambot
HamBot is a Bot for Slack focused on Amateur Radio use-cases. Currently HamBot
supports one command, which is callsign lookup:UsageYou’ll need a Slack API Token, which can be generated/retrieved as follows:Go to the Slack Web interface.Select Apps.Select Build.Select Custom.Select Bots.Name your bot whatever you’d like.Copy the API Token.Run the bot:export SLACKBOT_API_TOKEN='xoxb-XXXX-XXXX'
hambotInstallationYou’ll need to create a Slack Bot and create a Slack Bot API Token, then:pip install hambotSourceGithub:https://github.com/ampledata/hambotAuthorGreg Albrecht W2GMD <oss@undef.net>http://ampledata.org/CopyrightCopyright 2017 Greg AlbrechtLicenseApache License, Version 2.0. See LICENSE for details.