Saravanan666/pypi-org huggingface dataset:
Package: velikafkaclient
Kafka Client for VELI.STOREDescriptionThis module is used for producing kafka events, subscribing to kafka topics and consuming kafka events.To remember:Each kafka topic event has a predefined structure which you can see invelikafkaclient/eventregistration, producer
and consumer both have built in validation, meaning that if incorrect object structure is sent to a topic then producer
will raise an exception as well as consumer.How to use Producer/Consumer:Initialize kafka producer:BOOTSTRAP_SERVERS="kafka bootstrap servers uri"kafka_producer:AsyncKafkaEventProducer=AsyncKafkaEventProducer(BOOTSTRAP_SERVERS)awaitkafka_producer.start()Produce events to a topic:fromevents.baseimportKafkaEventfromtopics.baseimportBaseTopickafka_event=KafkaEvent()awaitkafka_producer.produce_event(BaseTopic,kafka_event)Setup and start consumerasyncdefbase_handler(kafka_event:KafkaEvent):print(str(kafka_event))bootstrap_servers=BOOTSTRAP_SERVERconsumer=AsyncKafkaConsumer(bootstrap_servers,group_id=GROUP_ID)consumer.subscribe(BaseTopic,base_handler)awaitconsumer.start()awaitconsumer.consume()How to add topics:To add a new topic you need three things:Topic itselfTopic event structureRegister Event structure to a TopicAll changes are done invelikafkaclientlibrary (in theveli_libsrepo)To add a topic go tokafka-client/velikafkaclient/topicsand add topic like this:classSomeTopicCollection(KafkaTopic):USER_REGISTRATIONS='user_registrations'To add an event structure go tokafka-client/velikafkaclient/eventsand create pydantic model for event structure:classUserRegistrationEvent(KafkaEvent):id:intusername:strpassword:strusername:strTo register event structure to a topic go tokafka-client/velikafkaclient/eventregistration.pyand add:kafka_topic_events.register_topic_event_model(KafkaTopic.USER_REGISTRATIONS,UserRegistrationEvent)Once done follow the instructions in theveli_libsreadme to update the library onpyipHow to manage topics with TopicManager:fromvelikafkaclient.topicmanagerimportKafkaTopicManagerclient=KafkaTopicManager(BOOTSTRAP_SERVERS)# Create Topicclient.create_topic('topic_name')# Create Multiple Topicstopics=['topic_name_1','topic_name_2']client.create_topics(topics)# List Topicsprint(client.list_topics())# Delete Topicclient.delete_topic('topic_name')# Delete Multiple Topicstopics=['topic_name_1','topic_name_2']client.delete_topics(topics)# Check if topic existsprint(client.topic_exists('topic_name'))
Package: velilogger
Logger for VELI.STOREDescriptionThis module used for logging, for each session it's possible to create a random UUID which will be saved in the
context of the session and every time anything is logged in that session will have that UUID (tracing-id)Golden Rule !!!If a session is initiated by an external request, a 'tracing-id' should be generated as soon as the request hits
our system. All actions undertaken during this session should be logged under this same 'tracing-id'. This is the
case even when a session begins with one service and subsequently connects to another service; the 'tracing-id'
must be shared across.How to log:fromveliloggerimportloggerlogger.info('some log message <3')# `tracing-id` will be in the logs automatically if it's generated correctlyHow to generatetracing-id:GenerallyTo generate randomtracing-idand save it in the session context:fromveliloggerimportgenerate_tracing_idgenerate_tracing_id()To save customtracing-idin the session context:fromveliloggerimportgenerate_tracing_idcustom_tracing_id="8538732c-12eb-4370-91bb-1a4fb850263f"# this may be received from another servicegenerate_tracing_id(custom_tracing_id)In FastAPIfromfastapiimportFastAPI,Requestfromveliloggerimportgenerate_tracing_idapp=FastAPI()@app.middleware("http")asyncdefhttp_middleware(request:Request,call_next):tracing_id_header='X-tracing-id'tracing_id=Noneiftracing_id_headerinrequest.headers:tracing_id=request.headers.get(tracing_id_header)generate_tracing_id(tracing_id)response=awaitcall_next(request)returnresponseWhen usingvelikafkaclient:veliloggeris integrated in thevelikafkaclient, when producing an eventtracing-idis set into the
kafka event object automatically, you just have to set it session begins, during consumption you must use@tracingdecorator to extracttracing-idfrom the event object and set it in the session contextfromvelikafkaclient.decoratorsimporttracingfromvelikafkaclient.events.baseimportKafkaEvent@tracingasyncdefevent_handler(event:KafkaEvent):# Handler logicpass
Package: velintegrator
VELIntegrator - Package for third-party integrations ;)Description
This module helps you to have a base class of Integrator and CRUDIntegrator,
which are used to connect to third-party service providers.Integrator Base class provide request validation posting data in different services,
CRUDIntegrator helps to create, read, update and delete objects in third-party services.There are also handler Base class, for handling data before sending it. you can find it in handler.pyBase handler attributes:class BaseHandler:
web_integrator = None
ios_integrator = None
android_integrator = None
event_model = None
params_methods_mapper = {}
base_params_method = None
params_method = None
tracing_id = Nonefeel free to use it.
Package: vell
VellA tool for spell checking multiple files in a folder. Sometimes when you write a document for your project but you get misspelled words you don't knowGetting StartedInstallingpip install --upgrade vellCheck spellCreatevell.iniconfig file based onvell.sample.iniRun the bello command to check spell:vellCheck spell on specific foldervell ./testCustomvell.iniconfig fileSome misspelled words like 'my_var' are your definition and they appear many time, you can ignore them by theirs frequency of appearance
In this case. I tell to vell if a word appear more than 5 times, they will be ignored[spell]
level_ignore = 5
...Vell checks multiple files with specific extensions. To add more type of files:[spell]
...
extensions =
	.html,
        .rst,
	README.md,
...Some misspelled words likehtml, envare keywords, you can ignore them when checking[spell]
...
ignore_words =
        ; code
        html

        ; environment
        env
...To exclude paths you don't want vell to check spell:...
[path]
exclude =
	.env,
	.vscode,
        __pycache__,
...
Package: vellum-ai
Vellum Python LibraryThe Vellum Python Library provides access to the Vellum API from python.API DocsYou can find Vellum's complete API docs atdocs.vellum.ai.Installationpipinstall--upgradevellum-aiUsageimportvellumfromvellum.clientimportVellumclient=Vellum(api_key="YOUR_API_KEY")result=client.generate(deployment_name="my-deployment",requests=[vellum.GenerateRequest(input_values={"question":"Can I get a refund?"})])print(result.text)Async Clientimportvellumfromvellum.clientimportAsyncVellumraven=AsyncVellum(api_key="YOUR_API_KEY")asyncdefgenerate()->str:result=client.generate(deployment_name="my-deployment",requests=[vellum.GenerateRequest(input_values={"question":"Can I get a refund?"})])returnresult.textUploading documentsDocuments can be uploaded to Vellum via either the UI or this API. Once uploaded and indexed, Vellum's Search allows you to perform semantic searches against them.fromvellum.clientimportVellumclient=Vellum(api_key="YOUR_API_KEY")withopen("/path/to/your/file.txt","rb")asfile:result=client.documents.upload(# File to uploadcontents=file,# Document labellabel="Human-friendly label for your document",# The names of indexes that you'd like this document to be added to.add_to_index_names=["<your-index-name>"],# Optionally include a unique ID from your system to this document later.#   Useful if you want to perform updates laterexternal_id="<your-index-name>",# Optionally include keywords to associate with the document that can be used in hybrid searchkeywords=[],)print(result)Beta statusThis SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning the package version to a specific version in your pyproject.toml file. This way, you can install the same version each time without breaking changes unless you are intentionally looking for the latest version.ContributingWhile we value open-source contributions to this SDK, this library is generated programmatically. Additions made directly to this library would have to be moved over to our generation code, otherwise they would be overwritten upon the next generated release. Feel free to open a PR as a proof of concept, but know that we will not be able to merge it as-is. We suggest opening an issue first to discuss with us!On the other hand, contributions to the README are always very welcome!
Package: vellum-client
:no_entry: [DEPRECATED] Active athttps://github.com/vellum-ai/vellum-client-pythonVellum Python LibraryThe Vellum python library provides convenient access to the Vellum Predict API from python applications.Installation$pipinstallvellum-clientUsageSetupYou'll need an API key from your Vellum account to use this library. You can create an API key from within your accounthere.
We recommend setting it as an environment variable.Generating TextHere's an example of initializing the library with the API key
loaded from an environment variable and initiating a generation:importvellumvellum.api_key="<YOUR_API_KEY>"result=vellum.Generate.run(deployment_name="my-deployment",requests=[vellum.GenerateRequest(input_values={"question":"Can I get a refund?"})])print(result.text)Submitting ActualsSubmitting actuals is how you provide feedback to Vellum about the quality of the generated text.
This feedback can be used to measure model quality and improve it over time.importvellumvellum.api_key="<YOUR_API_KEY>"vellum.SubmitCompletionActuals.run(deployment_name="customer-service-demo",actuals=[vellum.CompletionActual(id="<id-returned-from-generate-endpoint>",quality=1.0,# 1.0 is good, 0.0 is badtext="Sorry, we do not offer refunds.",)])Note:If you don't want to keep track of the ids that Vellum generates, you can include an externalId key in
the initial generate request. You can then include this externalId when submitting actuals. If you use this
approach, be sure that the ids you provide truly are unique, or you may get unexpected results.Uploading Documents to Search AcrossDocuments can be uploaded to Vellum via either the UI or this API. Once uploaded and indexed,
Vellum's Search allows you to perform semantic searches against them.
Here is an example of how to upload a document from a local file:importvellumvellum.api_key="<YOUR_API_KEY>"withopen("/path/to/your/file.txt","rb")asfile:result=vellum.UploadDocument.run(# File to uploadcontents=file,# Document labellabel="Human-friendly label for your document",# The names of indexes that you'd like this document to be added to.add_to_index_names=["<your-index-name>"],# Optionally include a unique ID from your system to this document later.#   Useful if you want to perform updates laterexternal_id="<your-index-name>",# Optionally include keywords to associate with the document that can be used in hybrid searchkeywords=[],)print(result)Performing a SearchVellum's Search allows you to upload documents and then perform semantic searches against them.
Here is an example of how to perform a search:importvellumvellum.api_key="<YOUR_API_KEY>"result=vellum.Search.run(index_name="help-center-docs",query="What is fine tuning?",options=vellum.SearchOptions(limit=3),)print(result)
Package: velocem
VelocemThis is a Work-In-Progress experimental Python C extension. It aims to provide
a stupid-fast, pointlessly low-latency, web development framework.If you use this code in production you get what you deserve.LicenseThe Velocem source code (and associated build/test/utility files) is released
into the public domain via CC0-1.0, seeLicensefor details.I (Vito Gamberini) hold no patents and have no knowledge of any patented
techniques used by Velocem. However, some organizations refuse to incorporate or
distribute public domain code due to patent concerns, for this reason Velocem is
additionally licensed for use under Zlib, seeUsageLicensefor details.As the source code itself is public domain, there is no need to retain licensing
information in full or partial source code distributions unless the patent
concerns are of significance to you.The purpose in using these well known legal texts is that they are widely
trusted and understood by the open source community. A bespoke legal text might
limit usage by particularly skittish developers or organizations. However, I
want to make my intentions clear in plain English as well:Do what you want with this stuff. There are zero restrictions on the use of
this code in any context.
Package: velociraptor
Velociraptor Python LibraryVelociraptorcatalogues provide
a signifciant amount of information, but applying units to it can be painful.
Here, theunytpython library is used to automatically apply units to
velociraptor data and perform generic halo-catalogue reduction. This library
is primarily intended to be used onSWIFTdata that
has been post-processed with velociraptor, but can be used for any
velociraptor catalogue.The internals of this library are based heavily on the internals of theswiftsimiolibrary, and essentially
allow the velociraptor catalogue to be accessed in a lazy, object-oriented
way. This enables users to be able to reduce data quickly and in a
computationally efficient manner, without having to resort to using theh5pylibrary to manually load data (and hence manually apply units)!RequirementsThe velociraptor library requires:unytand its dependenciesh5pyand its dependenciespython3.6or aboveNote that for development, we suggest that you havepytestandblackinstalled. To create the plots in the example directory, you will need
the plotting frameworkmatplotlib.InstallationYou can install this library from PyPI using:pip3 install velociraptorDocumentationFull documentation is available onReadTheDocs.Why a custom library?This custom library, instead of something likepandas, allows us to
only load in the data that we require, and provide significant
context-dependent features that would not be available for something
generic. One example of this is the automatic labelling of properties,
as shown in the below example.fromvelociraptorimportloadfromvelociraptor.toolsimportget_full_labelcatalogue=load("/path/to/catalogue.properties")stellar_masses=catalogue.apertures.mass_star_30_kpcstellar_masses.convert_to_units("msun")print(get_full_label(stellar_masses))This outputs "Stellar Mass $M_*$ (30 kpc) $\left[M_\odot\right]$", which is
easy to add as, for example, a label on a plot.
Package: velocity
Velocity is an elegant DNS caching library for Python. It intercepts all the DNS/Protocol resolution calls and caches them.
That's it, everything that makes network connections gets a performance boost.Liked the project?Buy me a coffee.DocumentationInstallationGetting startedManaging local cacheManually caching hostnamesAccessing cache databasesInstallationThe recommended way to installvelocityis by using pip as follows:pip install velocityGetting startedVelocity just needs to be imported to be activated.
For example, the following program will start using cached DNS responses after the first request.importrequestsimportvelocityforiinrange(10):requests.get('https://s0md3v.github.io')Important:If you are using threads, consider caching the hostnames manually to prevent the database getting
affected from race conditions.Managing local cacheThe cache can be stored locally. None of the following methods return anything or take arguments, just call them at will.importvelocityvelocity.flush_db()# deletes the local cachevelocity.save_db()# saves the in-memory cache locallyvelocity.load_db()# loads the local cache into memoryManually caching hostnamesA hostname can be cached manually as follows:importvelocityvelocity.cache(hostname)Note: IPv6 address are mapped to IPv4 addresses by default, which shouldn't be a problem. To avoid this behaviour and use IPv6 address instead, add an reachable port number asvelocity.cache(hostname, port)Accessing databaseIn-memory cache databases can be accessed with their respective variable names.velocity.dns_cache: Contains {hostname:ip} pairsvelocity.addr_cache: Contains {hostname:getaddrinfo_object} pairsContributions & LicenseFeel free to report any bugs you encounter, request features, give suggestions and fix bugs.Pull requests that do not imrpovevelocityas a program will not be accepted. Such as typo fixes, adding.gitignorefile,
pep8 styled code structure etc.Licensed under the GPLv3, seeLICENSEfor more information.Liked the project?You can support the developer by leaving a tip.PaypalPatreon
Package: velocity-estimation
velocity-estimationTwo dimensional velocity estimation methods for coarse-grained imaging data. Traditional methods compute the velocity
components in a given directions from the time delay between signals separated in such direction. This approach is inaccurate and can lead to big errors if
the velocity of propagation is not aligned with the separation between the two measurement points. At least
three points need to be considered, and time delays in two different directions need to be used simultaneously for
the accurate estimation of the velocity vector. The code in this repository implements such method for imaging
data. The underlying time delay estimation can be switched from cross-correlation analysis or cross-conditional
averaging.Installgit clone https://github.com/uit-cosmo/velocity-estimation.git
cd velocity-estimation
pip install .UseThe main function is two_dim_velocity_estimates.estimate_velocity_field(ds, eo), its usage is described in a notebook under the guides/ folder.
Package: velocity-optimization
Velocity optimizationOptimizes (Maximizes) the velocity profile for a vehicle in real-time respecting physical constraints (e.g., power,
force, combined acceleration, ...). Takes into account a variable friction potential between road and tires. Max.
power input can be space-variable (for, e.g., energy strategy purposes).DisclaimerThis software is provided as-is and has not been subject to a certified safety validation. Autonomous Driving is a highly complex and dangerous task. In case you plan to use this software on a vehicle, it is by all means required that you assess the overall safety of your project as a whole. By no means is this software a replacement for a valid safety-concept. See the license for more details.DocumentationThe public documentation is available throughReadTheDocs.The internal development documentation can be found onGitLab.PublicationThe preprint of the accepted version of the corresponding paper is available onarXiv.The paper is available onIEEE eXploreand will soon be in the printed
version of the IEEE Transactions on Intelligent Vehicles:@article{Herrmann2020,
 author = {Herrmann, Thomas and Wischnewski, Alexander and Hermansdorfer, Leonhard and Betz, Johannes and
 Lienkamp, Markus},
 year = {2021},
 title = {{Real-Time Adaptive Velocity Optimization for Autonomous Electric Cars at the Limits of Handling}},
 pages = {665--677},
 volume = {6},
 number = {4},
 issn = {2379-8904},
 journal = {{IEEE Transactions on Intelligent Vehicles}},
 doi = {10.1109/TIV.2020.3047858}
}
Package: velocycle
VeloCycleManifold-constrained variational inference for RNA velocity of the cell cycle. This is the repository for the VeloCycle framework. Installation instructions and tutorials can be found below.Getting startedPlease refer to the installation instructions below as well as thetutorialscontained in this repo.InstallationYou need to have Python 3.8 or newer installed.We suggest installing VeloCycle in a separate conda environment, which for example can be created with the command:condacreate--namevelocycle_envpython==3.8You will probably need to install git next:condainstallgitThen you can install VeloCycle using one of the following two approaches:Install the latest release on PyPI:pipinstallvelocycleInstall the latest development version:pipinstallgit+https://github.com/lamanno-epfl/velocycle.git@mainRelease notesThis is the initial release of VeloCycle corresponding to an upcoming preprint. These software are still under continuous development.ContactFor questions and help requests, you can reach out toAlex LedererandGioele La Manno. We are happy to hear your feedback and comments!
If you found a bug, please use theissue tracker.Additional materialsFor notebooks and data files not used in the tutorials included in this repo, but used in the original publication, please see the followingZenodopage andGEO, both of which are coming soon!.CitationComing soon!
Package: velodata
velo-pythonPython library for Velo API access.See full documentation here.Installpip install velodataUsagefromvelodataimportlibasvelo# new velo clientclient=velo.client('api_key')# get futures and pick onefuture=client.get_futures()[0]# get futures columns and pick twocolumns=client.get_futures_columns()[:2]# last 10 minutes in 1 minute resolutionparams={'type':'futures','columns':columns,'exchanges':[future['exchange']],'products':[future['product']],'begin':client.timestamp()-1000*60*11,'end':client.timestamp(),'resolution':1}# returns dataframeprint(client.get_rows(params))Streaming rowsRow requests are broken up into batches past a certain size. If you don't want to wait for all your requests to finish before receiving any data, you can use this:batches=client.batch_rows(params)fordfinclient.stream_rows(batches):print(df)LicenseCopyright 2023 Velo Data, license MIT
Package: velodyn
RNA velocity infers a rate of change for each transcript in an RNA-sequencing experiment based on the ratio of intronic to exonic reads. This inferred velocity vectors serves as a prediction for the future transcriptional state of a cell, while the current read counts serve as a measurement of the instantaneous state. Qualitative analysis of RNA velocity has been used to establish the order of gene expression states in a sequence, but quantitative analysis has generally been lacking.velodyn adopts formalisms from dynamical systems to provide a quantitative framework for RNA velocity analysis. The tools provided by velodyn along with their associated usage are described below. All velodyn tools are designed to integrate with the scanpy ecosystem and anndata structures.We have released velodyn in association with a recent pre-print. Please cite our pre-print if you find velodyn useful for your work.Differentiation reveals the plasticity of age-related change in murine muscle progenitorsJacob C Kimmel, David G Hendrickson, David R KelleybioRxiv 2020.03.05.979112; doi:https://doi.org/10.1101/2020.03.05.979112
Package: velog-hits
🍕 velog-hitsvelog-hits는 자신의 velog 게시글 조회수 통계를 종합해서 한 눈에 보기 쉽도록 HTML 파일로 만들어주는 프로젝트입니다.📍 Demo Image📍 시작하기1) 파이썬 버전Python >= 3.82) 설치조회수 종합 통계 데이터를 저장할 폴더 생성$mkdirvelog-hits-data생성한 폴더로 이동$cdvelog-hits-datapip 설치$pipinstallvelog-hits📍 사용방법1) 도움말 명령어$velog-hits-husage:velog-hits[-h]-uUSERNAME-atACCESSTOKEN

VelogHits

optionalarguments:-h,--helpshowthishelpmessageandexit-uUSERNAME,--usernameUSERNAMEVelogUsername-atACCESSTOKEN,--accesstokenACCESSTOKENYourVelogAccessToken2) Velog Hits 실행⚠️ Access Token을 모르신다면 해당 기능을 사용하실 수 없습니다.Velog Hits를 사용하기 위해서는 자신의Velog Username(=ID)와Access Token이 필요합니다."조회수 통계"는 로그인 했을 때만 볼 수 있는 기능이기 때문에 Access Token이 필요합니다. Access Token을 통해 본인임을 인증할 수 있습니다.$velog-hits-u{username}-at{access_token}'{username}'님의조회수데이터를가져오고있으니잠시만기다려주세요:)'{username}'님의조회수데이터를모두가져왔습니다!!
HTML로변환을시작합니다...
VelogHitsSuccess!!
VelogHitsResult:{오늘날짜.html파일위치경로}3) 결과 확인결과로 나온{오늘날짜.html 파일 위치 경로}부분을 복사한 후웹 브라우저를 열고 주소창에붙여넣기합니다.조회수 종합 통계 데이터는.../velog-hits-data/htmlhits/에 저장됩니다.명령어를 실행시킨 위치에htmlhits/폴더가 생성되고htmlhits/오늘날짜.html 파일이 생성됩니다.그렇기 때문에시작하기-설치부분에서 데이터 저장 폴더를 생성하고 해당 폴더로 이동한 것입니다.
Package: velopy
velo.pyView it on GitlabAboutLibrary for simple calculations with respect to road cycling and training.Full documentation with lots of examples available injupyter notebook.InstallationpipinstallvelopyTo use without installing just copy velopy.py to your local directory.UsageSimply import and specify your own FTP which might differ from the default value (290 W).importvelopyvelopy.FTP=250help(velopy)