Saravanan666/pypi-org huggingface dataset:
Package: pyatasm
Python wrapper for ATasm, a mostly Mac/65 compatible 6502 cross-assemblerSummaryFrom the ATasm readme:ATasm is a 6502 command-line cross-assembler that is compatible with the
original Mac/65 macroassembler released by OSS software.  Code
development can now be performed using "modern" editors and compiles
with lightning speed.pyatasm is a python wrapper that uses the (slightly modified) C code from
ATasm. It provides the front end to the assembler and returns the bytes (and
other metadata) from the assembly.Prerequisitespython 2.7 (but not 3.x yet) capable of building C extensionsInstallationpyatasm is available through PyPI:pip install pyatasmor you can compile from source:git clone https://github.com/robmcmullen/pyatasm.git
cd pyatasm
python setup installYour version of python must be able to build C extensions, which should be
automatic in most linux and on OS X. You may have to install the python
development packages on linux distributions like Ubuntu or Linux Mint.Windows doesn’t come with a C compiler, but happily, Microsoft provides a
cut-down version of their Visual Studio compiler just for compiling Python
extensions! Download and install it fromhere.DevelopersIf you check out the pyatasm source from the git repository or you want to
modify pyatasm and change the .pyx file, you’ll need Cython. The .pyx file is
compiled to C as a side effect of using the command:python setup.py sdistUsageA simple example:#!/usr/bin/env python

from pyatasm import Assemble

asm = Assemble("tests/works.m65")

if asm:
    print asm.segments
    print asm.equates
    print asm.labels
else:
    print asm.errorsBecause pyatasm is a very thin wrapper around ATasm (and very little ATasm code
was changed) it needs to creates files to do its work. These files will be
created in the same directory as the source file, so the directory must be
writeable.The segments attribute will contain a list of 3-tuples, each tuple being the
start address, the end address, and the bytes for each segment of the assembly.
A segment is defined as a contiguous sequence of bytes. If there is change of
origin, a new segment will be created.Licensepyatasm, python wrapper for ATasmATasm is Copyright (c) 1998-2014 Mark Schmelzenbach
pyatasm is Copyright (c) 2016 Rob McMullen (feedback@playermissile.com)This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Package: pyATC
pyatcPython tools for working with proprietary Alivecor ATC files in both python 2 and python 3.Supports reading and writing ATC files, reading from and writing to JSON and exporting toEDF(not plus) format.Installationpyatc is available onpypi.Install using pip withpip install pyatcUsageThis sample requires you to have a file named in.atc in the same folder as the script.from pyatc.pyatc import PyATC

f = PyATC.read_file("in.atc") #Read ATC
f.write_json_to_file("out.json") #Write json
f.write_to_file("out.atc") #Write ATC
f.write_edf_to_file("out.edf") #Write EDFPlease refer totest.pyfor more usage.File supportCurrently only file version 2 & 3 is supported. If you don't know if your file is the right format, try reading the file and the library will throw anUnsupportedFileVersionExceptionif it is not.If you got ATC files of a different version than 2 & 3, and ideally knowledge on how to read them, please let me know so that the library can support them.
Package: pyatem
Library implementing the ATEM video switcher protocol and a GTK3.0 application![Screenshot of the control application](https://brixitcdn.net/metainfo/openswitcher.png)InstallationInstall the pyatem protocol module:setup.py build
sudo setup.py installBuild and install the gtk application and proxy:meson build
meson compile -C build
sudo meson install -C buildRun the application:switcher-controlThere is also theopenswitcher-install.shscript which will install the library, proxy and gtk application in
/usr/local for a quick installation of all components.External dependenciesThe only external dependency for pyatem is pyusb for the USB protocol support. It contains a native compiled module so
it also requires a toolchain and python-dev headers at build time.OpenSwitcher depends on the python bindings from gtk3.OpenSwitcher-proxy only depends on pyatem for the core functionality but it might need more dependencies when loading
specific frontends or backends:MQTT Frontend: paho-mqttDevelopingTo work on thepyatemlibrary the quickest way to get up and running is using theopenswitcher-develop.shscript
that will install thepyatemlibrary in devel mode where the files are symlinked to the git repository. It will also
install the proxy and gtk application in /usr/local which will use the symlinked library.Development happens on matrix on #openatem:brixit.nlProxyThere is also theopenswitcher_proxypython module in this repository. It will run an API wrapper around one or
more ATEM switchers. There is currently a single api supported which is a HTTP REST api for sending commands and
reading the mixer state.It can be run by starting the module:python3 -m openswitcher_proxy --config /etc/myconfigfile.tomlOr if the software installed it can be started using the launcher script:openswitcher-proxy --config /etc/myconfigfile.tomlThe default config location is /etc/openswitcher/proxy.toml if not specified. Here’s an example config:[[hardware]]
id = “mini”
label = “Atem Mini”
address = “192.168.2.84”[[hardware]]
id = “mini2”
label = “Local switcher”
address = “usb”[[frontend]]
type = “http-api”
bind = “:8080”
auth = true
username = “bob”
password = “hunter2”
hardware = “mini,mini2”[[frontend]]
type = “status”
bind = “127.0.0.1:8082”
auth = falseThe status frontend provides a simple html page with the state of the connected switchers and a list
of the enabled frontends.The http-api frontend provides a HTTP server that can return any of the supported fields as json and
trigger commands by sending a HTTP POST request with formfields or jsonTranslationsThe main language for the software is english, the translation for the project happens onhttps://hosted.weblate.org/projects/openswitcher
Package: pyatf
pyATF: The Auto-Tuning Framework (ATF) in PythonAuto-Tuning Framework (ATF) is a generic, general-purpose auto-tuning approach that automatically finds well-performing values of performance-critical parameters (a.k.a. tuning parameters), such as sizes of tiles and numbers of threads.
ATF works for programs written in arbitrary programming languages and belonging to arbitrary application domains, and it allows tuning for arbitrary objectives (e.g., high runtime performance and/or low energy consumption).A major feature of ATF is that it supports auto-tuning programs whose tuning parameters haveinterdependenciesamong them, e.g., the value of one tuning parameter has to be smaller than the value of another tuning parameter.
For this, ATF introduces novel process togenerating,storing, andexploringthe search spaces of interdependent tuning parameters (discussed in detailhere).ATF comes with easy-to-use user interfaces to make auto-tuning appealing also to common application developers.
The Interfaces are based on either:Domain-Specific Language (DSL), for auto-tuning at compile time (a.k.a. offline tuning) (discussedhere);General Purpose Language (GPL), for auto-tuning at runtime (a.k.a. online tuning), e.g., ofC++ programs(referred to ascppATF, and discussedhere) orPython programs(referred to aspyATF).The full GitHub repository forpyATF, i.e., ATF with its GPL-based Python interface can be foundhere.DocumentationThe full documentation is availablehere.InstallationpyATF requires Python 3.9+ and can be installed usingpip:pip install pyatfpyATF's pre-implemented OpenCL and CUDA cost functions require additional packages to be installed:OpenCL cost function:pip install numpy pyopenclFor the OpenCL cost function, a matching OpenCL runtime is also required, e.g., for Intel CPUs:pip install intel-opencl-rtCUDA cost function:pip install numpy cuda-python
Package: pyatlan
Atlan Python SDKThis repository houses the code for a Python SDK to interact withAtlan.Documentationhttps://developer.atlan.com/getting-started/python-sdk/AttributionPortions of the SDK are based on original work fromhttps://github.com/apache/atlas. Those classes that derive from this original work have an extra heading comment as follows:# Based on original code from https://github.com/apache/atlas (under Apache-2.0 license)Portions of the SDK are based on original work fromhttps://github.com/elastic/elasticsearch-dsl-py. Those classes that derive from this original work have an extra heading comment as follows:# Based on original code from https://github.com/elastic/elasticsearch-dsl-py.git (under Apache-2.0 license)License:CC BY 4.0,
Copyright 2022 Atlan Pte. Ltd.
Package: pyatlasclient
This repository is no longer maintained in favour of Official Apache Atlas' python client:https://pypi.org/project/apache-atlas/Apache Atlas Client in PythonApache Atlas client in Python. Only compatible with Apache Atlas REST
APIv2.Based on the awesome work done by Poullet in atlasclientFree software: Apache Software License 2.0Documentation:https://pyatlasclient.readthedocs.ioGet startedfromatlasclient.clientimportAtlasclient=Atlas('<atlas.host>',port=21000,username='admin',password='admin')client.entity_guid("<guid>").statusparams={'typeName':'DataSet','attrName':'name','attrValue':'data','offset':'1','limit':'10'}search_results=client.search_attribute(**params)forsinsearch_results:foreins.entities:print(e.name)print(e.guid)FeaturesLazy loading: requests are only performed when data are required and
not yet availableLeverages Python's Data Classes for Glossary.Resource object relationships: REST API from sub-resources are done
transparently for the user, for instance the user does not have to
know that it needs to trigger a different REST request for getting
the classifications of a specific entity.TODO featuresallow multiprocessingImplement CachingApply Data Classes to all entity types. For now only Glossary
endpoints are using it.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: pyatmo
pyatmoWarning:Due to personal reasons, I am currently unable to dedicate sufficient time to effectively manage this repository. Consequently, no attention will be given to existing or forthcoming issues until further notice.However, I want to assure you that I will continue to merge any pull requests that are submitted, provided they successfully pass the continuous integration tests and do not exhibit any glaring issues.I apologize for any inconvenience this may cause, and I sincerely hope to have the capacity to allocate more time to this repository in the near future. Your understanding is greatly appreciated.Simple API to access Netatmo devices and data like weather station or camera data from Python 3.
For more detailed information seedev.netatmo.comThis project has no relation with the Netatmo company.InstallTo install pyatmo simply run:pip install pyatmoDepending on your permissions you might be required to use sudo.
Once installed you can simply addpyatmoto your Python 3 scripts by including:import pyatmoNoteThe module requires a valid user account and a registered application.
Be aware that the module may stop working if Netatmo decides to change their API.DevelopmentClone the repo and install dependencies:git clone
cd pyatmo
pipenv install --devTo add the pre-commit hook to your environment run:pip install pre-commit
pre-commit installTestingTo run the full suite simply run the following command from within the virtual environment:pytestorpython -m pytest tests/To generate code coverage xml (e.g. for use in VSCode) runpython -m pytest --cov-report xml:cov.xml --cov pyatmo --cov-append tests/Another way to run the tests is by usingtox. This runs the tests against the installed package and multiple versions of python.toxor by specifying a python versiontox -e py310
Package: pyatmo-fork
Simple API to access Netatmo weather station data from any python script
For more detailed information seehttp://dev.netatmo.comI have no relation with the netatmo company, I wrote this because I needed it myself,
and published it to save time to anyone who would have same needs.### Install ###To install lnetatmo simply run:python setup.py installDepending on your permissions you might be required to use sudo.
Once installed you can simple add lnetatmo to your python scripts by including:import lnetatmo### Note ###this release is an interim release waiting for Netatmo dashboard finalization. As any work in progress, it can stop to work at any time if serious changes occurs.
Package: pyatmo-shanbs
Simple API to access Netatmo weather station data from any python script
For more detailed information seehttp://dev.netatmo.comI have no relation with the netatmo company, I wrote this because I needed it myself,
and published it to save time to anyone who would have same needs.### Install ###To install lnetatmo simply run:python setup.py installDepending on your permissions you might be required to use sudo.
Once installed you can simple add lnetatmo to your python scripts by including:import lnetatmo### Note ###this release is an interim release waiting for Netatmo dashboard finalization. As any work in progress, it can stop to work at any time if serious changes occurs.
Package: pyAtmosphere
pyAtmospherePhysics-based simulation of light propagation in turbulent atmosphere.Installation*Highly recommend to usevirtual environment.Use the package managerpipto install required packages.pipinstall-rrequirements.txtIf you want to use GPU for simulation, you need toinstallCUDAon your machine.
Additinally, thecupypython package is required. For example, for CUDA 11.0:pipinstallcupy-cuda110UsageGPU usageIf you want to enable GPU simulation, execute at the beginning of your script:frompyatmosphereimportgpugpu.config['use_gpu']=TrueQuickChannel examplefrompyatmosphereimportQuickChannelquick_channel=QuickChannel(Cn2=1e-15,length=10000,count_ps=5,beam_w0=0.09,beam_wvl=8.08e-07,aperture_radius=0.12)quick_channel.plot()Advanced channelimportnumpyasnpfrompyatmosphereimport(Channel,RectGrid,RandLogPolarGrid,GaussianSource,IdenticalPhaseScreensPath,SSPhaseScreen,CirclePupil,MVKModel,measures)channel=Channel(grid=RectGrid(resolution=2048,delta=0.0015),source=GaussianSource(wvl=808e-9,w0=0.12,F0=np.inf),path=IdenticalPhaseScreensPath(phase_screen=SSPhaseScreen(model=MVKModel(Cn2=5e-16,l0=6e-3,L0=1e3,),f_grid=RandLogPolarGrid(points=2**10,f_min=1/1e3/15,f_max=1/6e-3*2)),length=50e3,count=5),pupil=CirclePupil(radius=0.2),)channel_output=channel.run(pupil=False)intensity=measures.I(channel,output=channel_output)mean_x=measures.mean_x(channel,output=channel_output)Simulationsfrompyatmosphereimportsimulationsbeam_result=simulations.BeamResult(quick_channel,max_size=2000)pdt_result=simulations.PDTResult(quick_channel,max_size=6000)sim=simulations.Simulation([beam_result,pdt_result])sim.run(plot_step=1000)ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
Feel free to open new issues if you have any questions.LicenseGNU GPLv3
Package: pyatoa
Python's Adjoint Tomography Operations AssistantMisfit assessment for the modern tomographerPyatoa* is a waveform-based misfit quantification package, with additional
tools for measurement aggregation, and visualizations of inversion results.
It is meant to facilitate the execution and assessment of seismic waveform
inversion.Documentation, including install instructions, example problems and API, can
be found onRead the Docs.Pyatoa is under current active development, and is bundled with other
inversion software under theadjTomo organization.If you find any issues, have questions, or would like to join the community,
please feel free to open up aGitHub Issueorstart a discussion.The design philosophy ofPyatoais easy-to-use interface that
make tomography research approachable, flexible, and repeatable.*pronounced Py-uh-toe-uh (ˈpaɪəˈtoʊə), inspired by the famed volcano Krakatoa
Package: pyAtome
# Atome PyPi[![Build Status](https://travis-ci.org/BaQs/pyAtome.svg?branch=master)](https://travis-ci.org/BaQs/pyAtome)Get your energy consumption data from Atome, a Linky-compatible device made by Total/Direct-Energie.### Installing` pip install pyatome `## Running the tests
The tox configuration is already included.
Simply launch:` $ tox `(Do not forget to ‘pip install tox’ if you do not have it.)
Tests are written in the tests directory.
tests/data folder contains samples of Atome API for tests purposes.## Side notesAs there is no official documentation on the API, I had to reverse-engineer what is the one used in the Atome IOS APP.
This module will cover only the /api path, and not crawl the pages generated by the “graph-query” paths.## ContributingAny contribution is welcome, considering the number of features the API provides, there is room for improvement!## VersioningWe use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/baqs/pyAtome/tags).## Authors## LicenseThis project is licensed under the ASL 2.0 License - see the [LICENSE.md](LICENSE.md) file for details## AcknowledgmentsThanks to k20human for the original inspiration withhttps://github.com/k20human/domoticz-atome## Changelog### 0.1.x
- Better tests
- Added consumption feature### 0.0.x
First versions, providing live data only
Package: pyatproto
AT Protocol Python LibraryA wrapper for interacting with theAT Protocol API, specifically for theBlueskysocial network.Note: There are some hard-coded Bluesky method names in this library, so the current version will not work with other AT Protocol implementations. The plan is to change this as new servers become available.Getting StartedTo install the library, run:pip install pyatprotoQuickstartimport pyatproto as atproto
import os

ENDPOINT = os.environ.get("ATPROTO_ENDPOINT")
USERNAME = os.environ.get("ATPROTO_USERNAME")
PASSWORD = os.environ.get("ATPROTO_PASSWORD")

ap = atproto.AtProtoConfiguration(ENDPOINT, USERNAME, PASSWORD)

create_post = ap.create_post("My First Post")

print(create_post)Example Scriptsquickstart.py: Authenticate and create a post on Bluesky.crawler.py: Find the messages posted by each person a user follows, recursively (rate limits prevent this being used for crawling the whole network without adjusting the logic, however).unroll.py: Find the parent of a message for use with thebsky.linkthread unrolling feature.ContributingContributions are welcome, especially those that add more methods to the library. Please open an issue or pull request to contribute to the library.LicenseThis project is licensed under anMIT 0 License.Contributorscapjamesg
Package: pyatrea
PyAtreaPython library for communication with Atrea ventilation unitsInstall:python3 -m pip install pyatreaUsage examples:Initiate library:from pyatrea import pyatrea

atrea = pyatrea.Atrea("192.168.0.2","passwordOnAtreaWebsite")Get status of your unit with human readable identifications (if available):status = atrea.getStatus()
if(status == False):
    exit("Authentication failed")

for id, value in status.items():
    print(atrea.getTranslation(id) + ":" + value)Get human readable warnings and errors:status = atrea.getStatus()
params = atrea.getParams()

for warning in params['warning']:
    if status[warning] == "1":
        print(atrea.getTranslation(warning))
for alert in params['alert']:
    if status[alert] == "1":
        print(atrea.getTranslation(alert))
Package: pyats
pyATS is an end-to-end testing ecosystem, specializing in data-driven and
reusable testing, and engineered to be suitable for Agile, rapid development
iterations. Extensible by design, pyATS enables developers start with small,
simple and linear test cases, and scale towards large, complex and asynchronous
test suites.pyATS is initially developed internally in Cisco, and is now available to the
general public starting late 2017 throughCisco DevNet. Visit the pyATS
home page athttps://developer.cisco.com/site/pyats/pyATS PackageThis is the top-level package of pyATS. Installing it will automatically install
all pyATS components and dependencies.RequirementspyATS currently supports Python >=3.8 on Linux & Mac systems.Quick Start$pipinstallpyats#toinstallalpha/betaversions,add--pre$pipinstall--prepyatsFor more information on setting up your Python development environment,
such as creating virtual environment and installingpipon your system,
please refer toVirtual Environment and Packagesin Python tutorials.ExampleAs part of installation, examples showcasing various features & idioms of coding
in pyATS will be copied to your virtual environment underexamples/folder.In addition, you can also get a copy of these examples here:https://github.com/CiscoDevNet/pyats-sample-scriptsThe examples are self-explanatory, and includes the necessary instructions on
how to run them.
Package: pyats.aereport
pyATS is an end-to-end testing ecosystem, specializing in data-driven and
reusable testing, and engineered to be suitable for Agile, rapid development
iterations. Extensible by design, pyATS enables developers start with small,
simple and linear test cases, and scale towards large, complex and asynchronous
test suites.pyATS is initially developed internally in Cisco, and is now available to the
general public starting late 2017 throughCisco DevNet. Visit the pyATS
home page athttps://developer.cisco.com/site/pyats/AEReport PackageThis is a sub-component of pyATS that handles result collection & reporting.RequirementspyATS currently supports Python 3.4+ on Linux & Mac systems. Windows platforms
are not yet supported.Quick Start#installpyatsasawhole$pipinstallpyats#toupgradethispackagemanually$pipinstall--upgradepyats.aereport#toinstallalpha/betaversions,add--pre$pipinstall--prepyats.aereportFor more information on setting up your Python development environment,
such as creating virtual environment and installingpipon your system,
please refer toVirtual Environment and Packagesin Python tutorials.
Package: pyats.aetest
pyATS is an end-to-end testing ecosystem, specializing in data-driven and
reusable testing, and engineered to be suitable for Agile, rapid development
iterations. Extensible by design, pyATS enables developers start with small,
simple and linear test cases, and scale towards large, complex and asynchronous
test suites.pyATS is initially developed internally in Cisco, and is now available to the
general public starting late 2017 throughCisco DevNet. Visit the pyATS
home page athttps://developer.cisco.com/site/pyats/AEtest PackageThis is a sub-component of pyATS that handles test script definition and
execution.RequirementspyATS currently supports Python 3.4+ on Linux & Mac systems. Windows platforms
are not yet supported.Quick Start#installpyatsasawhole$pipinstallpyats#toupgradethispackagemanually$pipinstall--upgradepyats.aetest#toinstallalpha/betaversions,add--pre$pipinstall--prepyats.aetestFor more information on setting up your Python development environment,
such as creating virtual environment and installingpipon your system,
please refer toVirtual Environment and Packagesin Python tutorials.