Saravanan666/pypi-org huggingface dataset:
Package: gonio-imsoft
Goniometric imaging softwareGonioImsoft is a terminal user interface Python program
designed to control the
goniometric high-speed imaging experiments whererotary encoder values are read over serial (pySerial)NI-DAQmx is used for general input/output (nidaqmx)the camera is controlled over MicroManager (pymmcore)It was developed for the need of imaging 200 distinct
rotations (eye locations) per specimen fast, requiring
only the space bar to be pressed between the rotations.For general imaging, without these specific needs,
it is better to use MicroManager or other image
acquisition software.Following block diagram illustrates the used software architecture´´´
tui.py - GonioImsoft terminal user interface
|
core.py
|
|__ nidaqmx - Control NI boards (trigger, stimuli)
|
|__ pyserial - Read Arduino (rotation data)
|
|__ Camera Client
|Camera Server
|
|_ pymmcore - camera control using MicroManager
|__ tifffile - writes images/stacks
´´´Thanks to the camera server/client model,
the cameras can be ran on separate computers.
This parallel image acquisition allows using many cameras
without worrying about memory and bandwidth or processing
limits.Required hardware and current limitationsWindows (and Linux to some extent) tested.A MicroManager-supported camera deviceNational Instruments input/output board (NI specificity can be
lifted in future by using PyVISA or similar)Serial device reporting rotation values in format "pos1,pos2\n"For full description of the used hardware configuration,
please seethe GHS-DPP imaging methods articleHow to installRotary encodersRotary encoders monitor the rotation of the imaged specimen/sample.
They are
mechanically attached to their respective rotation stages.
Their state is digitally read out using an Arduino microcontroller.In our system, we used two 1024-step rotary encoders attached on
two perpendicular rotation stages.
If your system is identical, you can flasharduino/angle_sensors/angle_sensors.inoand use the Serial Monitor
in the Arduino IDE to confirm it works.If your system differs, you may have to modify the Arduinoinofile.
However, any serial device reporting rotations in format "pos1,pos2\n"
will do. Here, pos1 and pos2 are rotation steps (integers)
of the two encoders.Main software (using pip)First please make sure that you haveMicroManager installation with a working cameraNational Insturments cards configured with
namesDev1andDev2for input and output, respectivelyPython 3.6 or newerThen, use pip to installpip install gonio-imsoftHow to useYou can launch the main program usingpython -m gonioimsoft.tui
Package: gonk-ai
GonkGonk is a backend for building and versioning deep learning datasets. Its goal is to do the heavy lifting for storage, validation, and approval workflows to make labeling high-quality datasets more efficient.FeaturesWorks with any file typeStrongly defined annotation formats using JSON SchemaComplete dataset version history through event sourcingChange approval to enable collaboration with untrusted third partiesIn ProgressPoint-in-time release taggingReproducible dataset releasesCloning the full dataset historyCommon annotation schemasExample clientsInstallationThis will install the packages as well as an applicationgonk-api.RequirementsThese should be installed automatically but if you are having trouble, it requiresFlask,jsonschema,PyNaCl, andclick. The API tests requirerequests. All of these are listed insetup.py.We use a fancy feature from thetypinglibrary (typing.Self), soPython 3.11 or higheris required.PyPIpipinstallgonk-aiSourcegitclonehttps://github.com/ComputeHeavy/gonk.gitcdgonk
pipinstall.RunningThe commandgonk-apiwill run the Flask API.To initialize, go to the folder you would like everything stored in and use -gonk-apiinit--usernameUSERNAMEYou can manage users with -gonk-apiuserslist
gonk-apiusersaddUSERNAME
gonk-apiusersrekeyUSERNAMEWhen you add a user their API key will be printed once. Give that to them. If they lose it or you want to disable their access you can userekey.You can run the server with -gonk-apirunThis will spawn the Flask application onlocalhost:5000. This is running in Flask's default development mode and should not be used for production, but it is probably suitable for individuals small teams. We will have a more robust solution in the future.DocumentationThese docs cover the API as well as all modules.gonk-ai.readthedocs.ioDesignThe first two files to look at areinterfaces.pyandevents.py. The three main interfaces are theRecordKeeper,Depot, andState. TheRecordKeeperis the event storage, it acts as a linear log of events. TheDepotstores objects (files and annotations). With those two you have a complete history of the dataset. TheStateacts as the application service, validating and processing events, maintaining the current state of the dataset.The fileintegrity.pyhas two methods for maintaining event integrity. The default is hash-chaining, where the event being added is serialized to bytes and hashed in conjunction with the previous event's hash. The other method is for signatures, which will play a larger role in a peer to peer implementation.There are currently two implementations. There is a file system backedDepotandRecordKeeper. Then there is also a SQLite backedRecordKeeperandState. An immediate plan is to add PostgreSQL and S3-compatible (read: R2) implementations for a higher scale (hosted) service.TestsTo test the core modules you can just runpython test.pyintest/core. For the API tests, you'll have to initialize the API according to the README in that directory, have an instance running, thenpython test.pyin there.
Package: gon-pytorch
Gradient Origin Networks in PyTorchUnofficial PyTorch implementation ofGradient Origin Networks.ReconstructionsSamplesUsageTrainingRequirements:pytorchnumpyhydraAfter cloning the repository, a GON can be trained using thetrain_gon.pyscript:pythontrain_gon.pydataset.name=<MNIST|FashionMNIST|CIFAR10>dataset.root=<data-root>All configuration options are listed inconfig/config.yaml. See thehydradocumentation for more information on configuration.From CodeInstall the package:pipinstallgon-pytorchInstantiate a GON withNeRFpositional encodings:importtorchfromgon_pytorchimportNeRFPositionalEncoding,ImplicitDecoder,GON,SirenBlockFactorypos_encoder=NeRFPositionalEncoding(in_dim=2)decoder=ImplicitDecoder(latent_dim=128,out_dim=3,hidden_dim=128,num_layers=4,block_factory=SirenBlockFactory(),pos_encoder=pos_encoder)gon=GON(decoder)coords=torch.randn(1,32,32,2)image=torch.rand(1,32,32,3)# Obtain latentlatent,latent_loss=gon.infer_latents(coords,image)# Reconstruct from latentrecon=gon(coords,latent)# Optimize modelloss=((recon-image)**2).mean()loss.backward()Differences to the original implementationCross-entropy is used as loss instead of MSE as this seems to be improve resultsThe original implementation obtains gradients with respect to the origin by calculating the mean over the latent loss. This seems to cause a bias on the batch-size as the mean loss is evenly distributed on the single latents in the backward pass. This is fixed by summing over the batch dimension for the latent loss instead of using the mean.Latent modulation fromModulated Periodic Activations for Generalizable Local Functional Representationsis implemented and can optionally be used.Citations@misc{bondtaylor2021gradient,title={Gradient Origin Networks},author={Sam Bond-Taylor and Chris G. Willcocks},year={2021},eprint={2007.02798},archivePrefix={arXiv},primaryClass={cs.CV}}@misc{sitzmann2020implicit,title={Implicit Neural Representations with Periodic Activation Functions},author={Vincent Sitzmann and Julien N. P. Martel and Alexander W. Bergman and David B. Lindell and Gordon Wetzstein},year={2020},eprint={2006.09661},archivePrefix={arXiv},primaryClass={cs.CV}}@misc{mildenhall2020nerf,title={NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis},author={Ben Mildenhall and Pratul P. Srinivasan and Matthew Tancik and Jonathan T. Barron and Ravi Ramamoorthi and Ren Ng},year={2020},eprint={2003.08934},archivePrefix={arXiv},primaryClass={cs.CV}}@misc{mehta2021modulated,title={Modulated Periodic Activations for Generalizable Local Functional Representations},author={Ishit Mehta and Michaël Gharbi and Connelly Barnes and Eli Shechtman and Ravi Ramamoorthi and Manmohan Chandraker},year={2021},eprint={2104.03960},archivePrefix={arXiv},primaryClass={cs.CV}}
Package: gonzales
gonzalesA 3D N-body simulator.Project descriptionThis project is a parallel N-body simulator, which includes a user interface for overview and animation of simulation results.
The low level code is written in Cython and C, and the rest was developed with Python. Parallelization was achieved with OpenMP.
The GUI is written using PyQt5.Two main simulation types are available:Brute-force simulationBarnes-Hut simulationFor both cases, the simulator is collisionless, with a gravitational softening parameter which can be specified.
Simulation results are written into HDF5 format.DocumentationDocumentation can be foundhere.RequirementsPython 3, Pipa C compilerInstallationinstall fromPyPiwithpip install gonzales, preferably using
a virtual environment. For more details, see theinstallation docsAfter installing, you can do the following in order to verify everything is working correctly:run one of the examples, like the Solar system simulation:python -m gonzales.examples.solar_systemrun the default performance benchmark suite withimport gonzales; gonzales.run_default_benchmark()run the quick start snippet belowQuick start snippetimport gonzales as gnz
import numpy as np

# number of particles, gravitational constant and softening length
N = 10000
G, eps = 0.01, 1e-2

# initial conditions and masses
r = np.random.uniform(-1, 1, (N, 3))
v = np.zeros((N, 3))
m = np.ones(N)

# output file name
fn = 'results.hdf5'

# particle container
s = gnz.Space(r, v, m)

# Barnes-Hut simulation
sim = gnz.BHSimulation(s, fn, G, eps, 1000, np.zeros(3), 0.75)
sim.run(100, 0.01)

# Viewer for animation and results
gnz.run_viewer(fn)
Package: goodai-ltm
GoodAI-LTMGoodAI-LTM equips agents with text-based long-term memory by combining essential components such astext embedding models, reranking, vector databases, memory and query rewriting, automatic chunking,chunk metadata, and chunk expansion. This package is specifically designed to offer a dialog-centricmemory stream for social agents.Additionally, GoodAI-LTM includes a conversational agent component (LTMAgent) for seamlessintegration into Python-based apps.Installationpip install goodai-ltmUsage of LTMAgentCall thereplymethod of anLTMAgentinstance to get a response from the agent.from goodai.ltm.agent import LTMAgent



agent = LTMAgent(model="gpt-3.5-turbo")

response = agent.reply("What can you tell me about yourself?")

print(response)Themodelparameter can be the name of any model supported by thelitellm library.A session history is maintained automatically by the agent. If you want to start anew session, call thenew_sessionmethod.agent.new_session()

print(f"Number of messages in session: {len(agent.session.message_history)}")The agent has a conversational memory and also a knowledge base. You can tell the agentto store knowledge by invoking theadd_knowledgemethod.agent.clear_knowledge()

agent.add_knowledge("The user's birthday is February 10.")

agent.add_knowledge("Refer to the user as 'boss'.")

response = agent.reply("Today is February 10. I think this is an important date. Can you remind me?")

print(response)LTMAgentis a seamless RAG system. Theltm_agent_with_wikiexampleshows how to add Wikipedia articles to the agent's knowledge base.You can persist the agent's configuration and its memories/knowledge by obtainingits state as a string via thestate_as_textmethod.state_text = agent.state_as_text()

# Persist state_text to secondary storageTo build an agent from state text, call thefrom_state_textmethod.agent2 = LTMAgent.from_state_text(state_text)Note that this does not restore the conversation session. The persist the conversation sessioncall thestate_as_textmethod of the session.from goodai.ltm.agent import LTMAgentSession



session_state_text = agent.session.state_as_text()

# session_state_text can be persisted in secondary storage

# The session.session_id field can serve as an identifier of the persisted session

# Now let's restore the session in agent2

p_session = LTMAgentSession.from_state_text(session_state_text)

agent2.use_session(p_session)Additional informationVisit the Github page:https://github.com/GoodAI/goodai-ltm
Package: goodbc-python
DEPRECATION NOTICEUse of this library is not recommended if you need to interact with an MSSQL database (because UnixODBC and FreeTDS are flaky).You should instead check outgomssql-pythonwhich removes the need for UnixODBC and
FreeTDS.If you're interacting with some other ODBC-exposed database and you know what you're doing though, please fill your boots.goodbc-pythonThe purpose of this module is to provide a Python interface to the Golanggoodbcmodule.It was made very easy with the help of the Golanggopymodule.VersionsThis version (0.91) is the last version to support Python 2; all versions after this have been subject to a refactor and support Python 3
only.LimitationsPython command needs to be prefixed with GODEBUG=cgocheck=0 (or have that in the environment)PrerequisitesGo 1.13Python 2.7+pipvirtualenvwrapperpkgconfig/pkg-configunixodbcLinux:apt-get install unixodbc unixodbc-dev freetds-bin freetds-devOSX:brew install freetds --with-unixodbcInstallation (from PyPI)python -m pip install goodbc-pythonInstallation (for prod)python setup.py installMaking a python wheel install file (for distribution)python setup.py bdist_wheelSetup (for dev)Ensure pkg-config is installed Ensure unixodbc is installedmkvirtualenvwrapper -p (/path/to/pypy) goodbc-pythonpip install -r requirements-dev.txt./build.shGODEBUG=cgocheck=0 py.test -vWhat's worth knowing if I want to further the development?gopy doesn't like Go interfaces; so make sure you don't have any public (exported) interfacesthis includes a struct with a public property that may eventually lead to an interfaceExample Python usageTo create an ODBC session in Python do the following:from goodbc_python import Connection

ip = "127.0.0.1"
port = 5432
database = "test"
username = "test"
password = "test"

conn_str = """
            DRIVER={FreeTDS};
            TDS_VERSION=8.0;
            SERVER=%s;
            Port=%i;
            DATABASE=%s;
            UID=%s;
            PWD=%s;
        """ % (
    ip, port, database,
    username, password
).replace('\n', '').replace(' ', '')

connection = Connection(conn_str)
cursor = connection.cursor()

query = "SELECT NOW()"

cursor.execute(query)

records = cursor.fetchall()

print("Records:")
print(records)

cursor.close()
connection.close()This seems to leak quite badly when trying to connect and query a bad IP address when using the FreeTDS driver.FreeTDS v1.1.17, their latest stable but the problem persists. It could very well be an interaction between goodbc and the driver. Not sure
at this stage.To develop / run the testsMOUNT_WORKSPACE=1 ./test.sh bash
./build.sh
py.testTo test the sdist packagepy.testTo do some manual testing./manual_test.shThis will spin up a Docker container that tries to connect to a specific database (internal to FTP Solutions); if the database is not there
it'll simply fail (which is a good way to manually test for leaking memory).
Package: goodbudget-cli
goodbudget_cliCommand line tool to enter transactions into yourGoodbudgetaccount.InstallationDependenciesSelenium Chrome Webdriver (example of installation instructions)Install with pipx (or pip)$ pipx install goodbudget-cliInitialize and edit the configuration fileRungbto initially create a~/.config/goodbudget_cli/config.jsonfile.Edit theconfig.jsonfile to set thewebdriver_pathto the location of your Chrome webdriver.Edit theconfig.jsonfile to set theEnvelopesusing the name of your Goodbudget envelopes using the format of{ENVELOPE_NAME: [LIST OF ALIASES]}.UsageTo enter an expense:$ gb {Goodbudget household username or email}To enter income:$ gb {Goodbudget household username or email}  --incomeDemo$ gb foo@bar.com
Enter your Goodbudget password:
Logging in. Please wait...
Logged in.

Date of transaction (today / yesterday / mm/dd/yyyy): today
Payee: QFC
Amount: 40
Envelope (or type in 'remind'): groceries
Notes (optional):

        Summary of your expense:

            Date: 01/28/2023
            Payee: QFC
            Amount: $40
            Envelope: Groceries (based on your alias of 'groceries')
            Notes: <none>

Is everything correct? (Y/n) Y
Entering expense. Please wait...

Success! Your transaction was entered into Goodbudget.

Do you want to enter another transaction? (Y/n) n

Thank you for using goodbudget_cli! See you next time!
Package: good-cache
good_cachegood_cacheis a Python library that caches the output of your functions. If your function has to read large files as its input or if it has to read files in a directory, and optionally some non-file function parameter values such as a str, int, bool, etc. values thengood_cachecan remember the input combination and return the ouput to the caller as long as the input combination has been seen (and cached) bygood_cachepreviously.Here is an article that goes into some detail aboutgood_cache:https://medium.com/@arunsundaramco/boost-your-python-efficiency-with-good-cache-file-and-directory-based-caching-made-simple-d2218365b3caHere is the GitHub repo:https://github.com/arunsundaram50/good-cacheHere is the pip command to install it:pip install good_cacheHere’s a simple example of how you might use good_cache:from good_cache import fs_files_cache

@fs_files_cache(files='filenames')
def sum_numbers_in_files(filenames):
    result = 0
    for filename in filenames:
        with open(filename, 'rt') as file:
            numbers = list(map(int, file.readlines()))
            result += sum(numbers)
    return resultHere's an example of how you can evict a previous cache for a particular parameter(s)evicted = sum_numbers_in_files.evict(['a.txt', 'b.txt'])
Package: good-converter
2023.7.3
V0.1: 提供2个基础的格式转换功能：ann_to_bio参数：
- save_path：转换后的文件保存路径
- input_file：输入的文件路径ann_to_bmes参数：
- save_path：转换后的文件保存路径
- input_file：输入的文件路径
Package: gooddata-fdw
GoodData Foreign Data WrapperThis project delivers PostgreSQL foreign data wrapper extension built on top ofmulticorn.
The extension makesGoodDatainsights, computations and ad-hoc report data available in PostgreSQL as tables.
It can be selected like any other table using SQL language.SeeDOCUMENTATIONfor more details.RequirementsGoodDatainstallation; either running on your cloud
infrastructure or the free Community Edition running on your workstationPython 3.8 or newerThe GoodData Cloud Foreign Data Wrapper is tested with the latest version of multicorn (1.4.0) and PostgreSQL 12InstallationRefer to thedocumentation.Bugs & RequestsPlease use theGitHub issue trackerto submit bugs
or request features.ChangelogConsultGithub releasesfor a released versions
and list of changes.LimitationsFDW is suitable for small to medium insights results or scheduled reports created in the third party tools. Carefully consider use in a production environment.
Package: gooddata-pandas
GoodData PandasThis package contains a thin layer that utilizes gooddata-sdk and allows you to conveniently create pandas series and
data frames from the computations done against semantic model in yourGoodData.CNworkspace.SeeDOCUMENTATIONfor more details.RequirementsGoodData.CN installation; either running on your cloud
infrastructure or the free Community Edition running on your workstationPython 3.8 or newerInstallationRun the following command to install thegooddata-pandaspackage on your system:pip install gooddata-pandasExampleCreate an indexed and a not-indexed series:fromgooddata_pandasimportGoodPandas# GoodData.CN host in the form of uri eg. "http://localhost:3000"host="http://localhost:3000"# GoodData.CN user tokentoken="some_user_token"# initialize the adapter to work on top of GD.CN host and use the provided authentication tokengp=GoodPandas(host,token)workspace_id="demo"series=gp.series(workspace_id)# create indexed seriesindexed_series=series.indexed(index_by="label/label_id",data_by="fact/measure_id")# create non-indexed series containing just the values of measure sliced by elements of the labelnon_indexed=series.not_indexed(data_by="fact/measure_id",granularity="label/label_id")Bugs & RequestsPlease use theGitHub issue trackerto submit bugs
or request features.ChangelogConsultGithub releasesfor a released versions
and list of changes.
Package: gooddata-sdk
GoodData Python SDKThegooddata-sdkpackage provides a clean and convenient Python API to interact withGoodData.At the moment the SDK provides services to inspect and interact with the Semantic Model and consume analytics:Catalog Workspaces ServiceCatalog Workspace Content ServiceCatalog Data Source ServiceCatalog User ServiceCatalog Permission ServiceCatalog Organization ServiceInsights ServiceCompute ServiceTable ServiceSeeDOCUMENTATIONfor more details.RequirementsGoodData Cloud or GoodData.CN installationPython 3.8 or newerInstallationRun the following command to install thegooddata-sdkpackage on your system:pip install gooddata-sdkExampleCompute an insight:importgooddata_sdk# GoodData host in the form of urihost="http://localhost:3000"# GoodData user tokentoken="some_user_token"sdk=gooddata_sdk.GoodDataSdk.create(host,token)workspace_id="demo"insight_id="customers_trend"# reads insight from workspaceinsight=sdk.insights.get_insight(workspace_id,insight_id)# triggers computation for the insight. the result will be returned in a tabular formtable=sdk.tables.for_insight(workspace_id,insight)# and this is how you can read data row-by-row and do something with itforrowintable.read_all():print(row)Bugs & RequestsPlease use theGitHub issue trackerto submit bugs
or request features.ChangelogSeeGithub releasesfor released versions
and a list of changes.
Package: good-day
┌───────────────────────────────────────────────────────────┐   
                         _____                (●>●)          
 _______________ _______|     |_     (͡°͜ʖ͡°)__/____ __   __ 
|       |       |       |  _    |   |      ||       |  | |  |
|    ___|  ___  |  ___  | | |    |  |  _    |   _   |  |_|  |
|   | __| |▀-▀| | |▀-▀| | |_|    |  | | |   |  |_|  |       |
|   ||  | |___| | |___| |        |  | |_|   |       |_     _|
|   |_| |       |       |________|  |       |   _   | |   |  
|_______|_______|_______| \(●●)/    |______||__| |__| |___|  

└───────────────────────────────────────────────────────────┘Good Day!Welcome to Good Day!Good day begins.Happy coding!🔧 Install$ pip install --upgrade good-dayUsageRun in terminalRun with confidence in the terminal with the following command:$ good-dayDevelopmentTestpython ./tests/unit_test/test_good_day.py -vBuildpython setup.py sdist bdist_wheel
twine check dist/*Publishtwine upload --repository-url https://test.pypi.org/legacy/ dist/*
twine upload dist/*
Package: gooddaycoklat
FoobarMyGeometry adalah paket Python sederhana yang berisi modul untuk menghitung luas bentuk geometris.InstallationUse the package managerpipto install foobar.pipinstallmygeometryUsagefrom mygeometry.shapes.trapesium import Trapesium#Membuat objek Trapesium
trapesium_saya = Trapesium(alas=5, atas=7, tinggi=4)#Menghitung dan menampilkan luas trapesium
print(f"Luas trapesium: {trapesium_saya.luas()}")